Here is a common implementation of MVVM:
This example also utilises a CustomerController along with some services, all of which are supplied by the “Model”. If you’ve worked with Prism you’ll probably recognise this rather unorthodox implementation of MVC, something I’ve never been comfortable with. Injecting a controller into a ViewModel seems backasswards to me. I would prefer to have the Controller be aware of the ViewModel and indirectly control/manage the Views.
Aside from being awkward, this approach does work. But don’t expect your modules to be “modular”. Sure, within your solution it will have the appearance of being a module, but it won’t very portable. If you’re persistent and are dedicated, you can try to “reuse” the Customer module above, but be prepared to drag a half dozen dependent assemblies with it.
So, what is modularity without portability? Without portability, modularity is reduced to a code organisation concept.
Looking over this situation it occurred to me that the injection of dependencies in the ViewModel was pretty much unrestrained. If the ViewModel needed it, just add another parameter to the constructor. The entire Model was wide-open for consumption, provided it was registered with Unity. Needless to say, this leads to greater and greater consumption, until finally the ViewModel is entrenched in implementation.
When viewed as a microcosm, MVVM can act like a tiered architecture. And tiered architectures are great for scalable server applications, but pretty much ruin any hopes of portability.
The other undesirable aspect of this is, while the ViewModel may require the ability to display a MessageBox (provided by the IMessageService), it has no use for the other 10+ methods provided by the service. So, why not give it exactly what it needs – and no more.
One way to accomplish this through the introduction of a custom Model class:
Here the CustomerModel class defines exactly what the ViewModel demands of the Model. In effect, it is a subset of the Model and is specific to that ViewModel. It’s the ViewModel’s shopping list – “if you’re going to use me, this is my list of demands”. It is now up to the implementer to provide this functionality – which is where the responsibility belongs.
With this approach the ViewModel has now been liberated and all of the “dependencies” removed. Service methods have been replaced with delegates. The ICustomerService can reside in the module itself, effectively making the CustomerModule a self-contained, standalone assembly.
A side benefit is that the View now contains no code-behind and is no longer dependent on the ViewModel interface.
While working through this I’ve created a new Prism sample solution, which includes a CustomerModule and an OrdersModule, Implementation project and a Shell. I have reduced the module dependency down to a single Core assembly. The Implementation project contains controllers, core services, a persistence manager, etc. It knows about the modules and can orchestrate the workflow and manage the views. The controllers “wire up” the Model and inject them into the ViewModels.
At the moment, CustomerModule + Core is about as portable as it gets.