How can I change my model's properties using ICommand?

Question

I am making a Yahtzee game in an attempt to learn WPF/MVVM. I've made some progress, but I am struggling on how to give my dices a random int value ("rolling") using ICommand. So I have a Dice Class like this:

public class Die : INotifyPropertyChanged
    {
        int _id; 
        int _roll;
        bool _checked;
    }

These properties have all got constructors like this:

public bool Checked
    {
        get { return _checked; }
        set { _checked = value;
            OnPropertyChanged("Checked"); }
    }

"_id" is just a way to keep track of the dices, not even sure it's needed. "_roll" is a random value, which is the question at hand, and "_checked" is a checkbox the player can check off if he wants to keep this value for the next throw.

My ViewModel looks like this:

public class DiceViewModel : INotifyPropertyChanged
{
    Die _die;

    public DiceViewModel()
    {
        myDices = new ObservableCollection<Die>()
        {
            new Die { Id = 1, Roll = 0, Checked = false },
            new Die { Id = 2, Roll = 0, Checked = false },
            new Die { Id = 3, Roll = 0, Checked = false },
            new Die { Id = 4, Roll = 0, Checked = false },
            new Die { Id = 5, Roll = 0, Checked = false },
        };
    }
}

My best attempt at creating the commands is like this:

public class RollDiceCommand : ICommand
{
    private Action<object> _method;
    public event EventHandler CanExecuteChanged;

    public RollDiceCommand(Action<object> method)
    {
        _method = method;
    }

    public bool CanExecute (object parameter)
    {
        if ((bool)parameter == true)
        {
            return true;
        }
        else
            return false;
    }

    public void Execute(object parameter)
    {

    }
}

So the two things I can't understand how to create is how to see if each dice's _checked property is false or not, and if checked is false give the current Die a new number. I also need to loop through all 5 dices after hitting my "Roll Dice" button.

1. Do I need to make the RollDiceCommand into it's own file or put it with the VM/M?
2. How to get the _checked property as the CanExecute parameter
3. How to randomize one Dice's _roll value, I guess question 2 solves this one as well.

Answer 1

I'll try to help you on way how i do it:

1) ObservableCollection is right choice, but if you need infos from that collection, why not make a property??? Then you can in private write/create list and to outside it will be only readable

    public class DiceViewModel : INotifyPropertyChanged
    {
        Die _die;

        public DiceViewModel()
        {
            mMyDices= new ObservableCollection<Die>()
            {
                new Die { _id = 1, _roll = 0, _checked = false },
                new Die { _id = 2, _roll = 0, _checked = false },
                new Die { _id = 3, _roll = 0, _checked = false },
                new Die { _id = 4, _roll = 0, _checked = false },
                new Die { _id = 5, _roll = 0, _checked = false },
            };
        }
    private ObservableCollection<Die> mMyDices;
    public ObservableCollection<Die> MyDices 
    {
    public get {retrun mMyDices; }
    private set { SetProperty (mMyDices, value);     }
    //This is part from interface IProperty changed 
    }
}

2) If your command is with GUI connected, then yes put it in VM 3) Class where you implement CanExecute method, needs to have access to MyDices list. To get propertys you need to create them.

Your Dice class has 3 private variable. Which are only inside visible, just like in 1), to make them a property:

//to outside read-only, but only in Dice class is writable
public Checked {get; private set;} 

//to outside writable, readable
public Checked {get; set;} 

UPDATE:

public abstract class BaseViewModel: INotifyPropertyChanged
    {
      /// <summary>
        ///     Multicast event for property change notifications.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        ///     Checks if a property already matches a desired value.  Sets the property and
        ///     notifies listeners only when necessary.
        /// </summary>
        /// <typeparam name="T">Type of the property.</typeparam>
        /// <param name="storage">Reference to a property with both getter and setter.</param>
        /// <param name="value">Desired value for the property.</param>
        /// <param name="propertyName">
        ///     Name of the property used to notify listeners.  This
        ///     value is optional and can be provided automatically when invoked from compilers that
        ///     support CallerMemberName.
        /// </param>
        /// <returns>
        ///     True if the value was changed, false if the existing value matched the
        ///     desired value.
        /// </returns>
        protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] String propertyName = null) {
            if (Equals(storage, value)) {
                return false;
            }

            storage = value;
            this.OnPropertyChanged(propertyName);
            return true;
        }

        /// <summary>
        ///     Notifies listeners that a property value has changed.
        /// </summary>
        /// <param name="propertyName">
        ///     Name of the property used to notify listeners.  This
        ///     value is optional and can be provided automatically when invoked from compilers
        ///     that support <see cref="CallerMemberNameAttribute" />.
        /// </param>
        protected void OnPropertyChanged([CallerMemberName] string propertyName = null) {
            PropertyChangedEventHandler eventHandler = this.PropertyChanged;
            if (eventHandler != null) {
                eventHandler(this, new PropertyChangedEventArgs(propertyName));
            }
        }
}

I have a base class for VM created.