MVVM vs MVP vs MVC: The differences explained

May 6, 2011 by Joel

Posted under: Linked In, Software Development

For the consicise explanation, see MVVM vs MVP vs MVC: The concise explanation

Those who know me know that I have a passion for software architecture and after developing projects using Model-View-ViewModel (MVVM), Model-View-Presenter (MVP), and Model-View-Controller (MVC), I finally feel qualified to talk about the differences between these architectures. The goal of this article is to clearly explain the differences between these 3 architectures.

Contents [hide]

Common Elements

First, the let’s define common elements. All 3 of the architectures are designed to separate the view from the model.

Model

Domain entities & functionality
Knows only about itself and not about views, controllers, etc.
For some projects, it is simply a database and a simple DAO
For some projects, it could be a database/file system, a set of entities, and a number of classes/libraries that provide additional logic to the entities (such as performing calculations, managing state, etc)

Implementation: Create classes that describe your domain and handle functionality. You probably should end up with a set of domain objects and a set of classes that manipulate those objects.

View

Code that handles the display
Note that view related code in the codebehind is allowed (see final notes at the bottom for details)

Implementation: HTML, WPF, WindowsForms, views created programmatically – basically code that deals with display only.

Differences between Presenters, ViewModels and Controllers

This is the tricky part. Some things that Controllers, Presenters, and ViewModels have in common are:

Thin layers
They communicate with the model and the view

The features of each.

Presenter (Example: WinForms)

2 way communication with the view
View Communication: The view communicates with the presenter by directly calling functions on an instance of the presenter. The presenter communicates with the view by talking to an interface implemented by the view.
There is a single presenter for each view

Implementation:

Every view’s codebehind implements some sort of IView interface. This interface has functions like displayErrorMessage(message:String), showCustomers(customers:IList<Customer>), etc. When a function like showCustomers is called in the view, the appropriate items passed are added to the display. The presenter corresponding to the view has a reference to this interface which is passed via the constructor.
In the view’s codebehind, an instance of the presenter is referenced. It may be instantiated in the code behind or somewhere else. Events are forwarded to the presenter through the codebehind. The view never passes view related code (such as controls, control event objects, etc) to the presenter.

A code example is shown below.

//the view interface that the presenter interacts with
public interface IUserView
{
    void ShowUser(User user);
    ...
}
 
//the view code behind
public partial class UserForm : Form, IUserView
{
    UserPresenter _presenter;
    public UserForm()
    {
        _presenter = new UserPresenter(this);
        InitializeComponent();
    }
 
    private void SaveUser_Click(object sender, EventArgs e)
    {
        //get user from form elements
        User user = ...;
        _presenter.SaveUser(user);
    }
 
    ...
}
 
public class UserPresenter
{
    IUserView _view;
    public UserPresenter(IUserView view){
        _view = view;
    }
 
    public void SaveUser(User user)
    {
 ...
    }
    ...
}

ViewModel (Example: WPF, Knockoutjs)

2 way communication with the view
The ViewModel represents the view. This means that fields in a view model usually match up more closely with the view than with the model.
View Communication: There is no IView reference in the ViewModel. Instead, the view binds directly to the ViewModel. Because of the binding, changes in the view are automatically reflected in the ViewModel and changes in the ViewModel are automatically reflected in the view.
There is a single ViewModel for each view

Implementation:

The view’s datacontext is set to the ViewModel. The controls in the view are bound to various members of the ViewModel.
Exposed ViewModel proproperties implement some sort of observable interface that can be used to automatically update the view (With WPF this is INotifyPropertyChanged; with knockoutjs this is done with the functions ko.observable() and ko.observrableCollection())

Controller (Example: ASP.NET MVC Website)

The controller determines which view is displayed
Events in the view trigger actions that the controller can use to modify the model or choose the next view.
There could be multiple views for each controller
View Communication:
- The controller has a method that determines which view gets displayed
- The view sends input events to the controller via a callback or registered handler. In the case of a website, the view sends events to the controller via a url that gets routed to the appropriate controller and controller method.
- The view receives updates directly from the model without having to go through the controller.
  - Note: In practice, I don’t think this particular feature of MVC is employed as often today as it was in the past. Today, I think developers are opting for MVVM (or MVP) over MVC in most situations where this feature of MVC would have been used. Websites are a situation where I think MVC is still a very practical solution. However, the view is always disconnected from the server model and can only receive updates with a request that gets routed through the controller. The view is not able to receive updates directly from the model.

Implementation (for web):

A class is required to interpret incoming requests and direct them to the appropriate controller. This can be done by just parsing the url. Asp.net MVC does it for you.
If required, the controller updates the model based on the request.
If required, the controller chooses the next view based on the request. This means the controller needs to have access to some class that can be used to display the appropriate view. Asp.net MVC provides a function to do this that is available in all controllers. You just need to pass the appropriate view name and data model.

MVVM and MVP implementation seem pretty straightforward but MVC can be a little confusing. The diagram below from Microsoft’s Smart Client Factory documentation does a great job at showing MVC communication. Note that the controller chooses the view (ASP.NET MVC) which is not shown in this diagram. MVVM interactions will look identical to MVP (replace Presenter with ViewModel). The difference is that with MVP, those interactions are handled programmatically while with MVVM, they will be handled automatically by the data bindings.

General rules for when to use which?

MVP

Use in situations where binding via a datacontext is not possible.
Windows Forms is a perfect example of this. In order to separate the view from the model, a presenter is needed. Since the view cannot directly bind to the presenter, information must be passed to it view an interface (IView).

MVVM

Use in situations where binding via a datacontext is possible. Why? The various IView interfaces for each view are removed which means less code to maintain.
Some examples where MVVM is possible include WPF and javascript projects using Knockout.

MVC

Use in situations where the connection between the view and the rest of the program is not always available (and you can’t effectively employ MVVM or MVP).
This clearly describes the situation where a web API is separated from the data sent to the client browsers. Microsoft’s ASP.NET MVC is a great tool for managing such situations and provides a very clear MVC framework.

Final notes

Don’t get stuck on semantics. Many times, one of your systems will not be purely MVP or MVVM or MVC. Don’t worry about it. Your goal is not to make an MVP, MVVM, or MVC system. Your goal is to separate the view, the model, and the logic that governs both of them. It doesn’t matter if your view binds to your ‘Presenter’, or if you have a pure Presenter mixed in with a bunch of ViewModels. The goal of a maintainable project is still achieved.
Some evangelists will say that your ViewModels (and Presenters) must not make your model entities directly available for binding to the view. There are definitely situations where this is a bad thing. However, don’t avoid this for the sake of avoiding it. Otherwise, you will have to constantly be copying data between your model and ViewModel. Usually this is a pointless waste of time that results in much more code to maintain.
In line with the last point, if using WPF it makes sense to implement INotifyPropertyChanged in your model entities. Yes, this does break POCO but when considering that INotifyPropertyChanged adds a lot of functionality with very little maintenance overhead , it is an easy decision to make.
Don’t worry about “bending the rules” a bit so long as the main goal of a maintainable program is achieved
Views
- When there is markup available for creating views (Xaml, HTML, etc), some evangelists may try to convince developers that views must be written entirely in markup with no code behind. However, there are perfectly acceptable reasons to use the code behind in a view if it is dealing with view related logic. In fact, it is the ideal way to keep view code out of your controllers, view models, and presenters. Examples of situations where you might use the code behind include:
  - Formatting a display field
  - Showing only certain details depending on state
  - Managing view animations
- Examples of code that should not be in the view
  - Sending an entity to the database to be saved
  - Business logic

Tech notes

Thursday, December 12, 2013