Question

I have an ItemType that is coming from EF. This ItemType is wrapped in a ItemTypeViewModel. Many ItemTypes are wrapped in ItemTypeViewModels and are being put in a ObservableCollection in the ViewModel for the user control that will display them:

I use the CollectionView so I can page through them. The screen looks like this:

Now I’m thinking that the buttons that are used for paging that are in the user control could better be placed in the Window that will contain the user control. So, in my user control I know have commands like this:

But I want them to be in the window. I don’t know if this will be good design, but if I will go through with this, how to relay the commands from the window to the usercontrol?

Another question I have is how to fill the combobox in the user control. They will always have the same values, but the selected item will change per ItemType.

Answer 1

I know two ways how to do this.

1) Add new class, for example, MainWindowViewModel and add there 2 commands and an instance of UserControlViewModel (you haven’t said the title, so I will call it in this way). Here is a part of example:

public class MainWindowViewModel
{
    public UserControlViewModel ChildControlViewModel { get; set; }

    private Lazy<RelayCommand> nextCommand = new Lazy<RelayCommand>(() => 
        new RelayCommand(
            () => this.ChildControlViewModel.CollectionView.MoveCurrentToNext(),
            () => this.ChildControlViewModel.CollectionView.CurrentPosition < this.ChildControlViewModel.ItemTypes.Count - 1)); 

    public ICommand NextCommand
    {
        get { return nextCommand.Value; }
    }

    //prev command...
}

I have used the Lazy class, but the main idea is clear: the code is the same, except the call this.ChildControlViewModel.CollectionView instead of CollectionView.

2) Use the Messenger class.

This way isn’t so obvious and it has only one advantage: the viewmodels are loosely connected.

public class MainWindowViewModel
{
    public const string NextCommandNotification = "NextCommand";
    public const string PreviousCommandNotification = "PreviousCommand";
    private bool isNextCommandEnabled;
    private bool isPreviousCommandEnabled;

    public MainWindowViewModel()
    {
        this.NextCommand = new RelayCommand(
                                () => Messenger.Default.Send(new NotificationMessage<MainWindowViewModel>(this, NextCommandNotification)), 
                                () => this.isNextCommandEnabled);
        //prev command...

        Messenger.Default.Register<NotificationMessage<UserControlViewModel>>(this,
                msg =>
                {
                    if (msg.Notification == UserControlViewModel.CurrentItemChangedNotification)
                    {
                        this.isNextCommandEnabled = msg.Content.CollectionView.CurrentPosition < msg.Content.ItemTypes.Count - 1;
                        this.NextCommand.RaiseCanExecuteChanged();
                        //prev command...
                    }
                });
    }

    public ICommand NextCommand { get; private set; }
    //prev command...
}

public class UserControlViewModel
{
    public const string CurrentItemChangedNotification = "CurrentItemChanged";

    public UserControlViewModel()
    {
        Messenger.Default.Register<NotificationMessage<MainWindowViewModel>>(this,
                msg =>
                {
                    if (msg.Notification == MainWindowViewModel.NextCommandNotification)
                        this.CollectionView.MoveCurrentToNext();
                    else if (msg.Notification == MainWindowViewModel.PreviousCommandNotification)
                        this.CollectionView.MoveCurrentToPrevious();
                });

        this.CollectionView.CurrentChanged += (s,e) => Messenger.Default.Send(new NotificationMessage<UserControlViewModel>(this, CurrentItemChangedNotification))
    }
}

I’m not sure whether this code will work correctly. And it is not easy to explain.

The MainWindowViewModel class send the message when a user press the button. The UserControlViewModel class process the message, change the position of the current item, and send the CurrentItemChangedNotification message. The MainWindowViewModel class process this message and updates the CanExecute part of the command.

1st solution is better for me, but at the same time I use the Messenger class quite often. It depends on the situation.