Singleton ViewModel WPF

Question

I created a datagrid using a MVVM pattern ( almost exactly this example ). The end goal is to have a graph that plots all the data from this datagrid AND the datagrid should update when a point of the graph has been manually moved (drag). The plotted data is a bunch of inputs for a robot.

The way I intended to build this was with 1 model (list of input parameters), 2 viewmodels (one for the datagrid and one for the graph) and 2 views (same window).

The problem: both viewmodels should use/update the same ObservableCollection containing the list of inputs.

To tackle this issue I tried several approach:

• Mediator pattern - I don't understand it
• Dependency Injection - Same as for mediator pattern, all examples I found were to hard for me to understand
• Singleton patter - feels like I understand that one, but can't properly implement it (I'm using this example that I find clear)

To make things simple, I am currently only focusing on the datagrid. So using a Singleton + MVVM pattern, I'm trying to have it work the same way it used to (commands to add/remove row, drag and drop, updating the ObservableCollection ).

So this is the singleton class:

class SingletonDoliInputCollection : ViewModelBase
{
    #region Events
    void OnDoliCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
        // Update item count
        this.ItemCount = this.DoliInputCollection.Count;

        // Resequence list
        SetCollectionSequence(this.DoliInputCollection);
    }
    #endregion

    #region Fields
    private ObservableCollection<DoliInput> _doliInputCollection;
    private int _itemCount;
    //Singleton
    private static SingletonDoliInputCollection _instance;
    #endregion

    #region Singleton Constructor
    private SingletonDoliInputCollection() { }
    #endregion

    #region Properties   
    public ObservableCollection<DoliInput> DoliInputCollection
    {
        get => _doliInputCollection;
        set
        {
            _doliInputCollection = value;
            OnPropertyChanged("DoliInputCollection");
        }
    }

    public static SingletonDoliInputCollection GetInstance(ObservableCollection<DoliInput> DoliInputCollection)
    {
        if (_instance == null)
        {
            _instance = new SingletonDoliInputCollection();
            _instance.Initialise(DoliInputCollection);
        }

        return _instance;
    }


    public int ItemCount
    {
        get => _itemCount;
        set
        {
            _itemCount = value;
            OnPropertyChanged("ItemCount");
        }
    }
    /// <summary>
    /// Return selected item in the grid
    /// </summary>
    public DoliInput SelectedItem { get; set; }
    #endregion

    #region Manage Sequencing
    /// <summary>
    /// Resets the sequential order of a collection.
    /// </summary>
    /// <param name="targetCollection">The collection to be re-indexed.</param>
    public static ObservableCollection<T> SetCollectionSequence<T>(ObservableCollection<T> targetCollection) where T : ISequencedObject
    {
        // Initialize
        var sequenceNumber = 1;

        // Resequence
        foreach (ISequencedObject sequencedObject in targetCollection)
        {
            sequencedObject.SequenceNumber = sequenceNumber;
            sequenceNumber++;
        }

        // Set return value
        return targetCollection;
    }
    #endregion

    #region Private Methods
    #region Initialise
    private void Initialise(ObservableCollection<DoliInput> DoliInputCollection)
    {
        //Create inputList
        _instance.DoliInputCollection = new ObservableCollection<DoliInput>();

        //Add items
        _instance.AddInput("Load", 3, 2, 1);
        _instance.AddInput("Position", 3, 11, 1);
        _instance.AddInput("Position", 3, 2, 4);
        _instance.AddInput("Load", 3, 2, 1);

        //Subscribe to the event that gets trigger when change occurs
        _instance.DoliInputCollection.CollectionChanged += OnDoliCollectionChanged;

        //Start indexing items
        this.DoliInputCollection = SetCollectionSequence(this.DoliInputCollection);

        //Update if changes
        this.OnPropertyChanged("DoliInputCollection");
        this.OnPropertyChanged("GridParam");
    }
    #endregion

    #endregion

    #region Public Methods
    public void AddInput(string CTRL, double Destination, double Speed, double Duration)
    {
        this.DoliInputCollection.Add(new DoliInput(CTRL, Destination, Speed, Duration));
    }
    #endregion

}

The ViewModel class looks like that:

public class DataGridVM : ViewModelBase
{
    #region Constructor

    public ObservableCollection<DoliInput> DoliInputCollection { get; set; }
    public DoliInput SelectedItem { get; set; }

    public DataGridVM()
    {
        //ObservableCollection<DoliInput> DoliInputCollection = new ObservableCollection<DoliInput>();
        SingletonDoliInputCollection doliInputs = GetDoliInputCollectionInstance(DoliInputCollection);
        DoliInputCollection = doliInputs.DoliInputCollection;
        SelectedItem = doliInputs.SelectedItem;
        Console.WriteLine(doliInputs.DoliInputCollection.ToString());
    }

    #endregion

    #region Properties
    public ICommand DeleteItem { get; set; }
    public ICommand AddRow { get; set; }

    #endregion

    #region Private Methods
    #region Initialise
    private static SingletonDoliInputCollection GetDoliInputCollectionInstance(ObservableCollection<DoliInput> DoliInputs)
    {
        SingletonDoliInputCollection singleton = SingletonDoliInputCollection.GetInstance(DoliInputs);
        return singleton;
    }
    #endregion

    #endregion

}

And for the view, here is just on example of column formatting:

<!--[...]-->
xmlns:dataGrid="clr-namespace:InteractiveGraph.Grid"
<!--[...]-->
<DataGridTextColumn Binding="{Binding Path=(dataGrid:DoliInput.Speed), Mode=TwoWay}" Header="Speed" />
<!--[...]-->

Last a simplified version of the model (there are 3 other properties: CTRL, destination and duration, not displayed here)

public class DoliInput : ObservableObject, ISequencedObject
{
    #region Fields
    private double _speed;
    private int _seqNb;
    #endregion

    #region Properties

    public double Speed 
    { 
        get => _speed; 
        set 
        { 
            _speed = value; 
            OnPropertyChanged("Speed"); 
        } 
    }

    public int SequenceNumber 
    { 
        get => _seqNb;
        set
        {
            _seqNb = value;
            OnPropertyChanged("SequenceNumber");
        }
    }

    #endregion

    #region Constructor

    public DoliInput(){  }

    public DoliInput(string CTRL, double destination, double speed, double duration)
    {
        this._speed = speed;
    }
    #endregion
}

I tried to keep this as short as possible. If more info is necessary, I can add it.

Disclamer : I am obsviously not a professional coder. I'm doing this on the side and I try to learn new things. If you think my whole approach for this code is wrong, I'm entirely open to a new one.

Answer 1

Dependency injection means you pass the dependencies (in this case the data points) to the object (in this case view-model) instead of having objects create their own dependencies and having problems like the one you have right now when dependencies that need to be shared.

You can have the data centralized in some object that is passed to the constructors of both view-models. This however will require you to raise events/ implement INotifyPropertyChanged so that both view-models are aware of the change and raising PropertyChanged event.

You can also have one view-model being bound by two different views but make sure that you're not breaking the single responsibility principle. I think this approach should be preferred. Notice that you're not limited to any 1-1 relationship between view-models and views. You can have many views bound to one viewmodel, a view binding to several view-models etc...

In any case, avoid singletons, at least for this case.