Search
Close this search box.

MVVM Compared To MVC and MVP

At the recent Calgary Tech Days event I did a presentation on building composite applications with WPF and Silverlight. One question that I get asked frequently when I get to the part of explaining MVVM is how its different from patterns that seem too similar or identical, with MVC and MVP typically being the two common ones raised.

Usually my answer is that MVVM is very similar to the others, but it implies *stuff* that’s specific to Silverlight and WPF (how binding works, commanding, etc.). Unfortunately without concrete demonstrations of implementing the different patterns, its sometimes hard to verbally get across.

So below I have a comparison, pointing out the key differences between the patterns and why MVVM *is* different.

MVC – Model View Controller

Let’s look at MVC first. You’ll notice a few things about the diagram:

The input is directed at the Controller first, not the view. That input might be coming from a user interacting with a page, but it could also be from simply entering a specific url into a browser. In either case, its a Controller that is interfaced with to kick off some functionality.

There is a many-to-one relationship between the Controller and the View. That’s because a single controller may select different views to be rendered based on the operation being executed.

Note the one way arrow from Controller to View. This is because the View doesn’t have any knowledge of or reference to the controller.

The Controller does pass back the Model, so there is knowledge between the View and the expected Model being passed into it, but not the Controller serving it up.

MVP – Model View Presenter

Now let’s look at the MVP pattern. It looks very similar to MVC, except for some key distinctions:

The input begins with the View, not the Presenter.

There is a one-to-one mapping between the View and the associated Presenter.

The View holds a reference to the Presenter. The Presenter is also reacting to events being triggered from the View, so its aware of the View its associated with.

The Presenter updates the View based on the requested actions it performs on the Model, but the View is not Model aware.

MVVM – Model View View Model

So with the MVC and MVP patterns in front of us, let’s look at the MVVM pattern and see what differences it holds:

The input begins with the View, not the View Model.

While the View holds a reference to the View Model, the View Model has no information about the View. This is why its possible to have a one-to-many mapping between various Views and one View Model…even across technologies. For example, a WPF View and a Silverlight View *could* share the same View Model. However, my own feeling is that this is a bad practice and creates Franken-ViewModels that have too many responsibilities. It’s better to keep it as a one-to-one mapping instead.

You’ll also notice that the View has no idea about the Model in the MVVM pattern. This is because, as far as the View knows, its “Model” IS the View Model (hence its name). Because of how data-binding and other features like commanding work in WPF and Silverlight, there is rich communication between the View and View Model, isolating the View from having to know anything about what’s really happening behind the scenes.

Conclusion

We could have gone deeper with this discussion, talking about the two different variations of MVP that Martin Fowler describes, or bring in other associated patterns like Front Controller. But at a high level, I think this gives us a good idea of the major differences between the three patterns.

More Reading

Josh Smith has a fantastic article talking about implementing MVVM with WPF and why MVVM is better for WPF (and by extension Silverlight). You can read it here: http://msdn.microsoft.com/en-us/magazine/dd419663.aspx#id0090009

D

This article is part of the GWB Archives. Original Author: Darcy Lussier

Related Posts