So, it seems that my latest post has generated a lot of debate throughout the umbraco community. Thank you!
Me and my coworkers at Lund & Andresen IT (in Danish), has been using this method for a couple of months now, and we’ve found a couple of issues that I didn’t think of. But now I have taken in some input from the community as well as from my coworkers and now I am revisiting the method.
The main theme throughout the post still remains: No data access or umbraco logic in the views! The views must only display what they are being served. Nothing more, nothing less.
Where I was wrong
In the old post, I suggested that all doctypes must be mapped to a model using a mapper class. This is no longer true! The problem quickly showed it self when building a large site: With mappers, we essentially get waay to much data per view, and we generalize how data is extracted without taking in account for different circumstances. An other problem was that our controllers no longer have any work to do, other than calling a mapper and serving a view. So my MVC (Model View Controller) became a “MMVC” (Model Mapper View Controller), which was not intended.
Sample project
As promised on twitter, I have made a simple sample project that illustrates my points. Please feel free to download it and tell me what you think.
What has changed
Not that much has changed. I have only redefined the mapper roles and reinstated the controller roles:
Models
I have two types of models in mind for a basic umbraco site:
- Document type model
- Data model
Document type models represent real document types. They have the same inheritance structure as doctypes, meaning if a doctype is a child of a master doctype so must the representative model.
So if you have a doctype tree looking like this:
- MasterDocType
- TextPage
Then you will have these two models:
public class MasterDocTypeModel{}
// Please note, we inherit from the MasterDocTypeModel:
public class TextPageModel : MasterDocTypeModel {}
This way, when you add a property on the MasterDocType, you will only have to add said property on one model.
Besides containing properties mapped from a doctype, a Document Type Model, may also contain other properties, like menu items.
Data models are models that are not in any way related to doctypes. A great example is for menus. You don’t want to build an entire document type model for each item and descended items in a menu tree, when the only information you want are “Name”, “Url”, “IsActive” and “ChildNodes”.
This is where data models come in. A menu would list NavigationItemModels instead of a mixture of TextPageModel, NewsArchiveModel and so on and so forth.
Controllers
Controllers are more important than ever!
Controllers are the ones that builds models and serves them to the views. In other words, controllers build Document Type Models, and passes them to the views.
Again, I have two different types of controllers:
- Master controllers
- Document type controllers
Essentially, there must be a master controller for each master doctype, (a master doctype is a document type that has children), and a document type controller for each document that has a template attached.
So in my example above, we should have a master controller called MasterDocTypeController. This controller inherits from Umbraco.Web.Mvc.RenderMvcController and should not contain any actions!
The only thing these controllers must contain are two overloads of the inherited View()-method:
protected ViewResult View(MasterDocTypeModel model)
{
return this.View(null, model);
}
protected ViewResult View(string view, MasterDocTypeModel model)
{
// TODO: Set master doctype model values.
return base.View(view,model);
}
By creating these two methods, we are able to set values that are to be set on all models that inherits from MasterDocTypeModel.
Please note, Master controllers, can also inherit from each other, depending on the doctype structure.
A doctype controller, would then inherit from this master controller, and set values essential for said doctype and return the result from the View-method created before.
Mappers
Mappers have a much lesser role, but not less important role! Mappers are used to map data models. Data models are shared across controllers and are not doctype dependent, so we will only have a few properties to map, and can to it in a very generalized way.
Data models are inheritable, and this inheritability must be addressed in the mappers as well. It’s quite simple, so why not just do it when we build the mappers?
A mapper class is a static class with a single static method called Map().
It looks like this:
internal static class NavigationItemMappers
{
internal static TModel Map(TModel model, IPublishedContent content)
where TModel : NavigationItemModel
{
// TODO: Add mapping logic here.
return model;
}
}
Please note that the method is generic. This way we can call the mapper like so: Map(new SomeInheritedModel(), CurrentPage) and get SomeInheritedModel back, on which we can continue our work without type casting. This is quite useful in linq statements:
IEnumerable original = from c in someSource
select NavigationItemMappers.Map(new NavigationItemModel(),CurrentPage);
// This works, as well as the one above:
IEnumerable inherited = from c in someSource
select NavigationItemMappers.Map(new SomeInheritedModel(){
SomeProperty = c.SomeValue
},CurrentPage);
// This also works:
IEnumerable inheritedToOriginal = from c in someSource
select NavigationItemMappers.Map(new SomeInheritedModel(){
SomeProperty = c.SomeValue
},CurrentPage);
// This does not:
IEnumerable originalToInherited = from c in someSource
select NavigationItemMappers.Map(new NavigationItemModel(),CurrentPage);
As you see, same mapper, different methods and different types, meaning greater flexibility.
A not on the mappers: Mappers should not map lists or child elements! These can differ from page to page. What works on a front page might not work as well on descending pages.
To summarize
The original post is still valid!
Controllers must have greater responsibility and must be the ones to handle doctypes, not mappers!
Mappers should map only simple data models and not map lists or child elements.
Controllers must use mappers as they see fit. Controllers control the mappers, not the other way around!
