I’ve answered a couple of questions at StackOverflow regarding the benefit of View Models. Here is a summary of all my answers focusing on View Models in ASP.NET MVC.
Reason 1: Remove logic from your Views
When you start working with ASP.NET MVC, you’ll most likely ask yourself why you should use a View Model. Using your domain model or entity model works perfectly fine.
And it does. For a while. But as you continue to use your Models, you’ll discover that you have to add some adaptations in your Views. Here is a typical usage
adaptation (using the Razor View engine):
Your age: @(model.Age != 0 ? model.Age.ToString() : "n/a")
Not so bad, is it? The problem is that you have introduced logic into your View, which is bad for two reasons:
- You can not unit test that code, and the only way to make sure that it works is user testing.
- You need to repeat that code for every View that intends to use your Model (code duplication = code smell).
All those small adaptations will lead to a big mess eventually.
Reason two: Security
One of the biggest advantages with View Models is removing security risks. Your database objects or domain objects will most likely contain properties that the user
should not be able to change. It can be a property called
All those properties will automatically be changed by the model binder if they exist in the model (and are posted in the FORM, which is quite easy to do if you know HTML).
Simply remove them from the View Model and they’ll never be changed.
Reason three: Loose coupling
By using domain models or entity models, you are adding coupling between your lower layers and the presentation layer, and that is seldom good. Google “loose coupling” to find out more.
Basically, it means that if you change your domain/entity model, you have to change all your Views that use that Model. If you use a ViewModel, you only have to change the code
that maps between an entity/domain model and the View Model.
How to make the Model mapping easier
I usually use a framework called AutoMapper to manage the mappings between
View Models and other Models. AutoMapper and its alternatives usually let you use a single line of code to do the mapping.