ASP.NET MVC - Typed ViewData proposal - asp.net-mvc

Question

In a project I'm working on, I have a lot of "read-only" pages that don't have <form>s in; I also have a lot of form pages that also have a lot of readonly data pulled in from the controller.
Ordinarily you'd use ViewModels and have one ViewModel per view and the ViewModel contains all of the data for that view. That seems fair enough, except there's a problem:
In my head, I see the ViewModel as being a representation and an encapsulation of the entire data sent from the view back to the controller, but the ViewModel might contain data populated by the controller (such as SelectListItem[] Html.DropDownListFor() data) which cannot be populated by a view and sent back to the controller.
Sure, it is possible to have that data as part of the ViewModel and manually re-populate it before returning the View in the Controller's HttpPost-handling method, but I feel it needlessly complicates the controller's code (and you'd have to use UpdateModel() instead of the automatic updates that happen when you specify the model as an argument to the action method).
My solution to this is a typed ViewData object. I derive from ViewPage<TModel> to give ViewPage2<TModel,TData> where TData : ViewDataDictionary<TModel> and override (or shadow) the .ViewData property to return an instance of TData instead..
My questions are twofold:
Subclassing ViewPage seems easy enough, but where do I put the logic to handle the initialisation of my ViewPage2<TModel,TData> class?
Is there anything wrong with my approach?

Answer 1

I found a way to implement my ViewData / ViewModel approach without messing too much with ASP.NET MVC.
Here's how I did it:
This is my ViewPage2 class which exposes the strongly-typed ViewData object to views. Unfortunately you do need to use reflection to avoid the ViewPage's behaviour of creating a brand new ViewDataDictionary, but with statically cached FieldInfo objects it's no more expensive than MVC's dynamic controller/action lookup in routing.
public class ViewPage2<TModel,TData> : ViewPage<TModel> where TData : ViewDataDictionary<TModel> {
public ViewPage2() : base() {
}
private Boolean _dataPresent;
private TData _data;
public new TData ViewData {
get {
if( _dataPresent && _data == null ) {
_data = (TData)base.ViewData;
}
return _data;
}
}
// Cached in static class state for performance.
private static readonly FieldInfo _viewPage1ViewData;
private static readonly FieldInfo _viewPage2ViewData;
static ViewPage2() {
Type viewPage1 = typeof(ViewPage<TModel>);
_viewPage1ViewData = viewPage1.GetField("_viewData", BindingFlags.Instance | BindingFlags.NonPublic );
Type viewPage2 = typeof(ViewPage);
_viewPage2ViewData = viewPage2.GetField("_viewData", BindingFlags.Instance | BindingFlags.NonPublic );
}
protected override void SetViewData(ViewDataDictionary viewData) {
// ViewPage<TModel> creates a new ViewDataDictionary<TModel> when this method is called, even if viewData is of the correct type.
// The trick is to reimplement SetViewData and set base._viewData and basebase._viewData
if( viewData is TData ) {
_viewPage1ViewData.SetValue( this, viewData );
_viewPage2ViewData.SetValue( this, viewData );
_dataPresent = true;
} else {
base.SetViewData( viewData );
}
}
}
Then for each *.aspx file (I use the WebFormViewEngine) I just change the #Page directive:
<%# Page Language="C#" MasterPageFile="~/Site.Master" Inherits="Me.ViewPage2<Me.FormModel,Me.FormData>" %>
I'll admit the two generic type specifiers to make it a bit fiddly, but it's something you only need to set once.
Then in each controller it's just a matter of doing this:
public ActionResult Edit() {
FormData data = new FormData();
data.SomeStronglyTypedField = "foo";
this.ViewData = data;
}
In each view you can now benefit from strongly-typed view data:
<p><%= ViewData.SomeStronglyTypedField %></p>
And because ViewData is not part of the model there's the separation of concerns when dealing with POST-submitted data and the benefits of automatic binding:
[HttpPost]
public ActionResult Edit(EditModel model) {
if( !ModelState.IsValid ) {
// See how I can return the model object without modifying it. All I need to do is re-create the View data.
FormData data = new FormData();
data.SomeStronglyTypedField = "foo";
this.ViewData = data;
return View( model );
}
// persist to DB here
return RedirectToAction("View");
}
In practice I use a common BaseController class that handles the automatic creation and setting of ViewData objects so I don't need those three lines (FormData data... etc) in every action.