Changing ActiveItem of a different ViewModel from a different Window

[micah686]

I'm trying to figure out what is the best way to be able to change the active item of a different viewmodel than the control I'm currently on, without having to resort to singletons/static instances. For example, something like this:
. Then I could click the button, and have it switch over to something like this:
.

The Red is the ShellViewModel/RootViewModel.

	//Interfaces
	public interface IMainGridViewModelFactory
    {
        MainGridViewModel CreateMainGridViewModel();
    }

    public interface ISettingsViewModelFactory
    {
        SettingsViewModel CreateSettingsViewModel();
    }

    public interface IDebugViewModelFactory
    {
        DebugViewModel CreateDebugViewModel();
    }

//Shell Window container
    public class RootViewModel : Conductor<Screen>
    {
        public StatusBarViewModel StatusBarPage { get; set; }

        private readonly IContainer _container;
        private readonly IWindowManager _windowManager;
        private readonly IMainGridViewModelFactory _mainGridVmFactory;
        private readonly ISettingsViewModelFactory _settingsVmFactory;


        public static RootViewModel Instance { get; private set; }


        public RootViewModel(IContainer container, IWindowManager windowManager, IMainGridViewModelFactory mainGridFactory, ISettingsViewModelFactory settingsFactory,
		IDebugViewModelFactory debugFactory)
        {
            Instance = this;
            _container = container;
            _windowManager = windowManager;
			
            _mainGridVmFactory = mainGridFactory;
            _settingsVmFactory = settingsFactory;
			_debugVmFactory = debugFactory;
            App.StatusBar = _container.Get<StatusBarViewModel>();

        }

        protected override void OnViewLoaded()
        {
            var mainGridVm = _mainGridVmFactory.CreateMainGridViewModel();
            ActivateItem(mainGridVm);
            StatusBarPage = _container.Get<StatusBarViewModel>();
            
        }



//Create instance of the ViewModels
        public void ActivateSettingsClick()
        {
            var settingsVm = _settingsVmFactory.CreateSettingsViewModel();
            ActivateItem(settingsVm);
        }

        public void ActivateMainClick()
        {
            var mainGridVm = _mainGridVmFactory.CreateMainGridViewModel();
            ActivateItem(mainGridVm);
        }


        public void DebugClick()
        {
            var debugVm = _debugVmFactory.CreateDebugViewModel();
            ActivateItem(debugVm);
        }

    }

I'm trying to get rid of the "Instance" static instance. I'm also looking for a way where I could call something like ActivateSettingsClick(), to activate the settings ViewModel.

[canton7]

I normally use a separate navigation controller for this.

The NavigationController has a reference to the ShellViewModel, and tells it to display particular pages.
Things that need navigation have a reference to the NavigationController.

There's a often dependency cycle there, so I explicitly give the NavigationController a reference to the ShellViewModel in the Bootstrapper, after it's been constructed.

I put together a full working sample here: https://github.com/canton7/Stylet/tree/develop/Samples/Stylet.Samples.NavigationController . Let me know if you've got any questions!

[canton7]

Sure, just use normal generics. However:

1. You lose the ability to pass along parameters
2. Your pages now need to know what page they're navigating to, rather than telling the navigation controller e.g. "My Next button was clicked"

[micah686]

How should I modify the NavigateTo method to reflect the correct type being set? Here's what I currently have:

public class NavigationController<T>
    {
        private readonly Func<T> _controlViewModelFactory;
        public INavigationControllerDelegate Delegate { get; set; }

        public NavigationController(Func<T> controlViewModel)
        {
            this._controlViewModelFactory = controlViewModel ?? throw new ArgumentNullException();
        }

        public void NavigateTo(Type type)
        {
            //not sure how to specify the type for this.
        }
    }

[canton7]

Use generics rather than a Type object. And pass it to IContainer.Get

[micah686]

Ah, so I would add the IContainer to the ctor, and have the NavigateTo use the generic rather than a type. Then, in the NavigateTo, I would use the container with the generic to get the object, right?

[canton7]

Try it and see :)

[micah686]

So, a few questions with the example you listed.

1. I would need to do something like builder.Bind<Func<MyViewModel>>().ToFactory<Func<MyViewModel>>(c => () => c.Get<MyViewModel>()); for each of the ViewModels that I need to be able to navigate to with the navigation controller, right?
2. If I didn't have something similar to the HeaderViewModel from your example, there shouldn't be any circular dependencies, right? Or is that what the navigationController.Delegate = this.RootViewModel; in the protected override void OnLaunch() does?
3. For the NavigationController, would I have to do something like this?

public NavigationController(Func<Page1ViewModel> page1ViewModelFactory, Func<Page2ViewModel> page2ViewModelFactory)
        {
            this.page1ViewModelFactory = page1ViewModelFactory ?? throw new ArgumentNullException(nameof(page1ViewModelFactory));
            this.page2ViewModelFactory = page2ViewModelFactory ?? throw new ArgumentNullException(nameof(page2ViewModelFactory));
        }

Or would something like this work, since I have a fair amount of ViewModels that I might need to navigate to?

private readonly IContainer _container;
public NavigationController(IContainer container)
{
     _container = container
}

public void NavigateToPage1()
{
    var pg1 =  _container.Get<Func<Page1ViewModel>>();
    this.Delegate?.NavigateTo(pg1);
}

4. Just a general question about the Factories. Is something like this the correct to get a ViewModel, or does that make it an anti-pattern?

public ModifyGameHostViewModel(IContainer container)
        {
            _container = container;            
            var gamePath = _container.Get<Func<ModifyGamePathViewModel>>().Invoke();                        
            ActivateItem(gamePath);            
        }

[canton7]

If I didn't have something similar to the HeaderViewModel from your example, there shouldn't be any circular dependencies, right?

Correct. In that case you could let the ioc container inject the ShellViewModel directly into the NavigationController, without needing to explicitly assign it later in the bootstrapper.

Or would something like this work, since I have a fair amount of ViewModels that I might need to navigate to?

You can inject the IContainer, sure. That's the Service Locator pattern: it's often seen as an anti-pattern, but IMO it's fine for something like the NavigationController (although I wouldn't do it in a normal ViewModel).

Note that there's no need to fetch a Func<T> from the container and then invoke it: just fetch a T directly

var pg1 = _container.Get<Page1ViewModel>();

[micah686]

Yeah, the object passed as host should be the ModifyGameHostViewModel, since that's has the tabcontrol that hosts the other viewmodels.

[canton7]

Then you've got 2 basic options:

---

public class GameCardViewModel : Screen
{
    private readonly IWindowManager _windowManager;
    private readonly Func<ModifyGameHostViewModel> _modifyGameHostViewModelFactory;

    public GameCardViewModel(IWindowManager windowManager, Func<ModifyGameHostViewModel> modifyGameHostViewModelFactory) =>
        (_windowManager, _modifyGameHostViewModelFactory) = (windowManager, modifyGameHostViewModelFactory_);

    public void SettingsClick()
    {
        SetGameEntry();
        var modifyHost = _modifyGameHostViewModelFactory();
        modifyHost.SetSelectedGame(_selectedGame);
        _windowManager.ShowDialog(modifyHost);
    }
}

public class ModifyGameHostViewModel : Screen
{
    private readonly IWindowManager _windowManager;
    public ModifyGameHostViewModel(IWindowManager windowManager, ModifyGamePathViewModel gamePath, ModifyGameDeleteViewModel gameDelete)
    {
        _windowManager = windowManager;
        gameDelete.Host = this;
        Items.Add(gamePath);
        Items.Add(gameDelete);
            
        ActivateItem(gamePath);
    }
}

public class ModifyGameDeleteViewModel : Screen
{
    private readonly IWindowManager _windowManager;
    private readonly IEventAggregator _events;
    public ModifyGameHostViewModel  Host { get; set; }
    public ModifyGameDeleteViewModel(IWindowManager windowManager, IEventAggregator events)
    {
        DisplayName = App.ResMan.GetString("DeleteGame");
        _windowManager = windowManager;
        _events = events;
    }
}

---

public class GameCardViewModel : Screen
{
    private readonly IWindowManager _windowManager;
    private readonly Func<ModifyGameHostViewModel> _modifyGameHostViewModelFactory;

    public GameCardViewModel(IWindowManager windowManager, Func<ModifyGameHostViewModel> modifyGameHostViewModelFactory) =>
        (_windowManager, _modifyGameHostViewModelFactory) = (windowManager, modifyGameHostViewModelFactory_);

    public void SettingsClick()
    {
        SetGameEntry();
        var modifyHost = _modifyGameHostViewModelFactory();
        modifyHost.SetSelectedGame(_selectedGame);
        _windowManager.ShowDialog(modifyHost);
    }
}

public class ModifyGameHostViewModel : Screen
{
    private readonly IWindowManager _windowManager;
    public ModifyGameHostViewModel(IWindowManager windowManager, ModifyGamePathViewModel gamePath, ModifyGameDeleteViewModelFactory gameDeleteFactory)
    {
        _windowManager = windowManager;
        Items.Add(gamePath);
        Items.Add(gameDeleteFactory.Create(this));
            
        ActivateItem(gamePath);
    }
}

public class ModifyGameDeleteViewModelFactory
{
    private readonly IWindowManager _windowManager;
    private readonly IEventAggregator _eventAggregator;

    public ModifyGameDeleteViewModelFactory(IWindowManager windowManager, IEventAggregator eventAggregator) =>
        (_windowManager, _eventAggregator) = (windowManager, eventAggregator);

    public ModifyGameDeleteViewModel Create(ModifyGameHostViewModel host) =>
        new ModifyGameDeleteViewModel(_windowManager, _eventAggregator, host);
}

public class ModifyGameDeleteViewModel : Screen
{
    private readonly IWindowManager _windowManager;
    private readonly IEventAggregator _events;
    private readonly ModifyGameHostViewModel _host;
    public ModifyGameDeleteViewModel(IWindowManager windowManager, IEventAggregator events, ModifyGameHostViewModel  host)
    {
        DisplayName = App.ResMan.GetString("DeleteGame");
        _windowManager = windowManager;
        _events = events;
        _host = host;
    }
}

---

See how IContainer doesn't appear in either of them. Each VM takes the dependencies it needs in its ctor. If it needs a single instance of a child VM, it accepts that; if it needs to create multiple instances, it accepts a factory. We can use a factory when we need to pass extra parameters to a child VM's ctor.

[micah686]

SO the first option is when you just need a single instance without any extra parameters. The second option is for when you need multiple instances, or with additional parameters, am I understanding that right?

[canton7]

They're just two different ways of tackling the case where you've got a VM where some ctor parameters need to come from the ioc container, and other ctor parameters need to be passed in by the parent. The first snippet turns the ctor parameter which needs to be passed in by the parent into a property, and the second snippet uses a factory.

[micah686]

Ok, thanks, I think I understand it now. Tanks for your help