I've data architecture issues. My goal should be to have bidirectional data communication between ViewModels and the Model classes. I've one window with different usercontrols. Each usercontrol has it's own data, but some properties are shared between these. For each ViewModel I implemented two functions for synchronize the model and the viewmodel. The model should kept updated, so I implemented in the PropertyChanged event the method call SyncModel. This is so far not so nice, because when I call the constructor the method call chain is: constructor -> SyncViewModel -> Property setter -> PropertyChanged -> SyncModel

Here is some sample code to understand my problem better:

public class SampleModel
{
    public string Material { get; set; }
    public double Weight { get; set; }

    public double Length { get; set; }
    public double Width { get; set; }
    public double Height { get; set; }

    public object SharedProperty { get; set; }
}

public class SampleViewModelA : AbstractViewModel
{
    public string Material
    {
        get
        {
            return _Material;
        }

        set
        {
            if (value != _Material)
            {
                _Material = value;
                OnPropertyChanged(nameof(Material));
            }
        }
    }
    public double Weight
    {
        get
        {
            return _Weight;
        }

        set
        {
            if (value != _Weight)
            {
                _Weight = value;
                OnPropertyChanged(nameof(Weight));
            }
        }
    }
    public object SharedProperty
    {
        get
        {
            return _SharedProperty;
        }

        set
        {
            if (value != _SharedProperty)
            {
                _SharedProperty = value;
                OnPropertyChanged(nameof(SharedProperty));
            }
        }
    }

    public SampleViewModelA(SampleModel Instance) : base(Instance) { }

    public override void SyncModel()
    {
        //If I wouldn't check here, it would loop:
        //constructor -> SyncViewModel -> Property setter -> PropertyChanged -> SyncModel
        if (Instance.Material == Material &&
            Instance.Weight == Weight &&
            Instance.SharedProperty == SharedProperty)
            return;

        Instance.Material = Material;
        Instance.Weight = Weight;
        Instance.SharedProperty = SharedProperty;
    }

    public override void SyncViewModel()
    {
        Material = Instance.Material;
        Weight = Instance.Weight;
        SharedProperty = Instance.SharedProperty;
    }

    private string _Material;
    private double _Weight;
    private object _SharedProperty;
}

public class SampleViewModelB : AbstractViewModel
{
    //Same like SampleViewModelA with Properties Length, Width, Height AND SharedProperty
}

public abstract class AbstractViewModel : INotifyPropertyChanged
{
    //All ViewModels hold the same Instance of the Model
    public SampleModel Instance { get; set; }

    public event PropertyChangedEventHandler PropertyChanged;

    public AbstractViewModel(SampleModel Instance)
    {
        this.Instance = Instance;

        SyncViewModel();
    }

    protected virtual void OnPropertyChanged(string PropertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(PropertyName));
        SyncModel();
    }

    public abstract void SyncModel();
    public abstract void SyncViewModel();
}

The real problem is, that the SharedProperty need to be updated between the SampleViewModelA and the SampleViewModelB. First I thought the Observer Pattern could help me, but the SharedProperties are to various to make it work with generic interfaces. Then I thought a datacontroller with change events could help me like this

public class SampleDataController
{
    public SampleModel Instance { get; set; }

    public delegate void SynchronizeDelegate();
    public event SynchronizeDelegate SynchronizeEvent;

    public void SetSharedProperty(object NewValue)
    {
        if (Instance.SharedProperty != NewValue)
        {
            Instance.SharedProperty = NewValue;
            SynchronizeEvent?.Invoke();
        }
    }
}

If it would do it like this my AbstractViewModel would only communicate with the controller instead of the instance. The SyncModel function would call methods like SetSharedProperty instead of directly access. The MainViewModel code could look like this.

public class SampleMainViewModel
{
    public SampleViewModelA ViewModelA { get; set; }
    public SampleViewModelB ViewModelB { get; set; }

    public SampleDataController Controller { get; set; }

    public SampleMainViewModel()
    {
        ViewModelA = new SampleViewModelA(Controller);
        ViewModelB = new SampleViewModelB(Controller);

        Controller.SynchronizeEvent  = ViewModelA.SyncViewModel;
        Controller.SynchronizeEvent  = ViewModelB.SyncViewModel;
    }
}

This would cause the problem, that the source for the SynchronizeEvent call is also subscribed to the event itself. This wouldn't cause a infinity loop because I check if values are equal to the new state, but it seems very ugly to me. There must be a better way than this.

In my project I have 8 ViewModels and multiple model classes where I need to sychronize the data with different shared properties.

I'm thankful for any help and hope the problems are so far understandable.

CodePudding user response：

You already use a SampleMainViewModel which is composed of the other view model classes SampleViewModelA and SampleViewModelB.
Now all you have to do is to move all the properties that are shared between the view models/views (like the SharedProperty, but also Material and Weight) to the composed SampleMainViewModel or to a shared class in general. This way all your controls can bind to the same data source.

Also the communication between Model --> View Model should only take place via events: the Model can notify the View Model by exposing e.g., a DataChanged event. There is no real bi-directional communication/dependency between Model and View Model. That's the main characteristic of MVVM: the uni-directional dependency of the participating components - realized by implementing events, commands and especially by utilizing data binding.

The follwoing example shows how you bind your controls to shared properties and to unshared properties (those that are attributes of the specialized view model classes).

MainWindow.xaml

<Window>
  <Window.DataContext>
    <SampleMainViewModel />
  </Window.DataContext>

  <StackPanel>
    <UserControlA Material="{Binding Material}" 
                  SharedProperty="{Binding SharedProperty}" 
                  UnsharedPropertyA="{Binding ViewModelA.UnsharedPropertyA}" />

    <UserControlB Material="{Binding Material}" 
                  SharedProperty="{Binding SharedProperty}" 
                  UnsharedPropertyB="{Binding ViewModelB.UnsharedPropertyB}" />
  </StackPanel>
</Window>

SampleMainViewModel.cs

public class SampleMainViewModel : INotifyPropertyChanged
{
    public SampleViewModelA ViewModelA { get; }
    public SampleViewModelB ViewModelB { get; }

    /* Properties must raise INotifyPropertyChanged.PropertyChanged */
    public string Material { get; set; }
    public double Weight { get; set; }
    public object SharedProperty { get; set; }

    // Example initialization
    public SampleMainViewModel(SomeModelClass someModelClass)
    {
        this.ViewModelA = new SampleViewModelA();
        this.ViewModelB = new SampleViewModelB();

        this.Material = someModelClass.Material;
        this.Weight = someModelClass.Weight;
        this.SharedProperty = someModelClass.SharedProperty;

        someModelClass.DataChanged  = UpdateData_OnDataChanged;
    }

    private void UpdateData_OnDataChanged(object sender, EventArgs args)
    {
        var someModelClass = sender as SomeModelClass;
        this.Material = someModelClass.Material;
        this.Weight = someModelClass.Weight;
        this.SharedProperty = someModelClass.SharedProperty;
    }
}

SampleViewModelA.cs

public class SampleViewModelA : INotifyPropertyChanged
{
    public object UnsharedPropertyA { get; set; }
}

SampleViewModelB.cs

public class SampleViewModelB : INotifyPropertyChanged
{
    public object UnsharedPropertyB { get; set; }
}

"Your suggestion cause the disadvantage, that my separated ViewModels are no longer encapsulated. And if I would move all my code with shared properties to the MainViewModel, the class would end up very large"

To address your comment: if you insist in having a view model per each control including duplicating properties etc., then you must take a different approach.
Also moving the shared/duplicate code out of your view models does not break encapsualtion - assuming that those classes do not contain duplicated code only.

But note that a view model per each control is not recommended. You have a view/page - an aggregation of multiple controls - which has a defined data context. All controls in this view share the same data context - usually, as views are structured context related.
That's why the FrameworkElement.DataContext is inherited by default.

Having a view model for each control makes things overly complicated and leads to a lot of duplicated code - and not only duplicate properties like in your example. You will find yourself duplicating logic too. And talking about testability, if you duplicate logic you will duplicate unit tests too. This is because you are dealing with the same data and the same model classes.

You usually extract duplicate code to a separate class that is the referenced by the types that depend on this duplicate code. Refactoring your view model classes with this "no duplicate code" policy in mind would end up moving the "shared" properties to a separate class. Since we are talking about the data context of the same view, this separate class would be the view model class that is assigned to the DataContext of the page. I'm trying to say that your approach is doing the exact opposite: you duplicate code (and call it encapsulation). If the class ends up being very large because it contains a lot of properties then you may review your UI design - maybe you should split your big page into more pages with more concise content. This may will improve UX too.

Generally, there is nothing wrong with having a view model with some more properties. If your view model class contains lots of logic too, you can extract this logic to separate classes.

You can still use the pattern of the previous example, which is to listen to data changed events of the Model.

Either you implement a very general event like the above DataChanged event or several more specialized events like a MaterialChanged event. Also make sure to inject the same model instances into each view model.
The following example shows how you can have multiple different view model classes that expose the same data, where all these view model classes update themselves by observing their model classes:

MainWindow.xaml

<Window>
  <Window.DataContext>
    <SampleMainViewModel />
  </Window.DataContext>

  <StackPanel>
    <UserControlA DataContext="{Binding ViewModelA}"
                  Material="{Binding Material}" 
                  Weight="{Binding Weight}" 
                  SharedProperty="{Binding SharedPropertyA}" />

    <UserControlB DataContext="{Binding ViewModelB}"
                  Material="{Binding Material}" 
                  Weight="{Binding Weight}" 
                  SharedProperty="{Binding SharedPropertyB}" />
  </StackPanel>
</Window>

SampleMainViewModel.cs

public class SampleMainViewModel : INotifyPropertyChanged
{
    public SampleViewModelA ViewModelA { get; }
    public SampleViewModelB ViewModelB { get; }

    // Example initialization
    public SampleMainViewModel()
    {
        var sharedModelClass = new SomeModelClass();
        this.ViewModelA = new SampleViewModelA(sharedModelClass);
        this.ViewModelB = new SampleViewModelB(sharedModelClass);
    }
}

SampleViewModelA.cs

public class SampleViewModelA : INotifyPropertyChanged
{    
    /* Shared properties */
    public string Material { get; set; }
    public double Weight { get; set; }
    public object SharedProperty { get; set; }

    private SomeModelClass SomeModelClass { get; }

    // Example initialization
    public SampleViewModelA(SomeModelClass sharedModelClass)
    {    
        this.SomeModelClass = sharedModelClass;

        this.Material = this.SomeModelClass.Material;
        this.Weight = this.SomeModelClass.Weight;
        this.SharedProperty = this.SomeModelClass.SharedProperty;

        // Listen to model changes
        this.SomeModelClass.DataChanged  = UpdateData_OnDataChanged;
        this.SomeModelClass.MaterialChanged  = OnModelMaterialChanged;
    }

    // Example command handler to send dat back to the model.
    // This will trigger the model to raise corresponding data chnaged events
    // to notify listening view model classes that new data is available.
    private void ExecuteSaveDataCommand()
      => this.SomeModelClass.SaveData(this.Material, this.Weight);

    private void OnModelMaterialChanged(object sender, EventArgs args)
    {
        var someModelClass = sender as SomeModelClass;
        this.Material = someModelClass.Material;
    }

    private void UpdateData_OnDataChanged(object sender, EventArgs args)
    {
        var someModelClass = sender as SomeModelClass;
        this.Weight = someModelClass.Weight;
        this.SharedProperty = someModelClass.SharedProperty;
    }
}

SampleViewModelB.cs

public class SampleViewModelB : INotifyPropertyChanged
{
    /* Shared properties */
    public string Material { get; set; }
    public double Weight { get; set; }
    public object SharedProperty { get; set; }

    private SomeModelClass SomeModelClass { get; }

    // Example initialization
    public SampleViewModelB(SomeModelClass sharedModelClass)
    {    
        this.SomeModelClass = sharedModelClass;

        this.Material = this.SomeModelClass.Material;
        this.Weight = this.SomeModelClass.Weight;
        this.SharedProperty = this.SomeModelClass.SharedProperty;

        // Listen to model changes
        this.SomeModelClass.DataChanged  = UpdateData_OnDataChanged;
        this.SomeModelClass.MaterialChanged  = OnModelMaterialChanged;
    }

    // Example command handler to send dat back to the model.
    // This will trigger the model to raise corresponding data chnaged events
    // to notify listening view model classes that new data is available.
    private void ExecuteSaveDataCommand()
      => this.SomeModelClass.SaveData(this.Material, this.Weight);

    private void OnModelMaterialChanged(object sender, EventArgs args)
    {
        var someModelClass = sender as SomeModelClass;
        this.Material = someModelClass.Material;
    }

    private void UpdateData_OnDataChanged(object sender, EventArgs args)
    {
        var someModelClass = sender as SomeModelClass;
        this.Weight = someModelClass.Weight;
        this.SharedProperty = someModelClass.SharedProperty;
    }
}

A variation of the first solution (which aimes to eliminate duplicate code) is to refactor your binding source, that exposes the shared properties, by extracting those properties to new classes according to their responsibilities.

For example, you can have your MainViewModel expose a MaterialViewModel class that encapsulates material related properties and logic. This way MaterialViewModel can be mnade available globally.
Given that you follow the one-data-context-class per view principle, you can limit the scope of the shared properties to specific pages by having only their specific view model classes expose the same MaterialViewModel instance:

MainWindow.xaml

<Window>
  <Window.DataContext>
    <MainViewModel />
  </Window.DataContext>

  <StackPanel>
    <MaterialControl DataContext="{Binding MaterialViewModel}"
                     Material="{Binding Material}" 
                     Weight="{Binding Weight}" />

    <UserControlB ... />
  </StackPanel>
</Window>

MainViewModel.cs

public class MainViewModel : INotifyPropertyChanged
{
    // Since defined in 'MainViewModel' the properties of 'MaterialViewModel' 
    // are globally shared accross pages
    public MaterialViewModel MaterialViewModel { get; }

    /* View model classes per page */
    public ViewModelPageA PageViewModelA { get; }

    // If 'ViewModelPageB' would expose a 'MaterialViewModel', 
    // you can limit the visibility of 'MaterialViewModel' to the 'ViewModelPageB' DataContext exclusively
    public ViewModelPageB PageViewModelB { get; }

    // Example initialization
    public SampleMainViewModel()
    {
        var sharedModelClass = new SomeModelClass();
        this.MaterialViewModel = new MaterialViewModel(sharedModelClass);
        this.ViewModelPageA = new ViewModelPageA(sharedModelClass);

        // Introduce the MaterialViewModel to a page specific class
        // to make the properties of 'MaterialViewModel' to be shared inside the page only
        this.ViewModelPageB = new ViewModelPageB(sharedModelClass);
    }
}

MaterialViewModel.cs

public class MaterialViewModel : INotifyPropertyChanged
{
    public string Material { get; set; }
    public double Weight { get; set; }

    private SomeModelClass SomeModelClass { get; }

    // Example initialization
    public MaterialViewModel(SomeModelClass sharedModelClass)
    {    
        this.SomeModelClass = sharedModelClass;

        this.Material = this.SomeModelClass.Material;
        this.Weight = this.SomeModelClass.Weight;

        // Listen to model changes
        this.SomeModelClass.MaterialDataChanged  = OnModelMaterialChanged;
    }

    // Example command handler to send dat back to the model.
    // This will also trigger the model to raise corresponding data chnaged events
    // to notify listening view model classes that new data is available.
    // It can make more sense to define such a command in the owning  class,
    // like SampleMainViewModel in this case.
    private void ExecuteSaveDataCommand()
      => this.SomeModelClass.SaveData(this.Material, this.Weight);

    private void UpdateData_MaterialChanged(object sender, EventArgs args)
    {
        var someModelClass = sender as SomeModelClass;
        this.Material = someModelClass.Material;
        this.Weight = someModelClass.Weight;
    }
}