One thing that still puzzled me after reading and trying to follow the chapter was how to create complex custom ViewModels (as opposed to putting all data in the ViewData dictionary or using vanilla Linq to SQL entities). Scott mentions on page 107 of the book that you “might have the action method update a ViewModel object with the form-posted data, and then use the ViewModel instance to map or retrieve an actual domain model object”, but there is no actual example of how this would look in source code.

For example, let’s assume you have an edit action method with the following view:

So your edit form displays data coming from a Linq entity representing a customer (FirstName, LastName, Email, Country, AccountType), but you also need SelectLists to populate the Country and AccountType DropDownLists.

The simple, but untyped approach: the ViewData dictionary

The simplest approach is to use the Customer Linq entity as ViewModel and to put the two SelectLists in the ViewData dictionary. This works fine, but I dislike the fact that there is no type-safety for the two SelectLists. Instead you have to use a type cast from object to SelectList:

<label for="CountryCode">Country</label><br />
<%= Html.DropDownList("CountryCode",ViewData["Countries"] as SelectList)%>

<%= Html.ValidationMessage("CountryCode", "*")%>

The fully typed approach: Custom ViewModels

So you want fully typed model data, but the linq entity does not hold all the data you need to render the view. Since you don’t want to clutter my Customer Linq to SQL entity with two properties that return the two SelectLists, the only alternative to get a fully typed view is to use a custom ViewModel:

public class CustomersFormViewModel
{
public SelectList AccountTypes { get; set; }
public SelectList Countries { get; set; }
public Customer Customer { get; set; }
}

Note that the ViewModel is not a mere Linq entity anymore. Instead, it contains the one Customer Linq entity instance, plus the two SelectLists for my DropDownLists.

Now you can implement your view without using any typecasts:

<p>

<label for="Customer.FirstName">

FirstName:</label><br />

<%= Html.TextBox("Customer.FirstName")%>

<%= Html.ValidationMessage("Customer.FirstName", "*")%>

</p>

<p>

<label for="Customer.LastName">

LastName:</label><br />

<%= Html.TextBox("Customer.LastName")%>

<%= Html.ValidationMessage("Customer.LastName", "*")%>

</p>

<p>

<label for="Customer.Email">

Email:</label><br />

<%= Html.TextBox("Customer.Email")%>

<%= Html.ValidationMessage("Customer.Email", "*")%>

</p>

<p>

<label for="Customer.CountryCode">

Country</label><br />

<%= Html.DropDownList("Customer.CountryCode",Model.Countries)%>

<%= Html.ValidationMessage("Customer.CountryCode", "*")%>

</p>

<p>

<label for="Customer.AccountType">

AccountType:</label><br />

<%= Html.DropDownList("Customer.AccountType",Model.AccountTypes)%>

<%= Html.ValidationMessage("Customer.AccountType", "*")%>

</p>

I was wondering if the MVC framework can automatically map the form values and reconstruct a CustomersFormViewModel. In other words, can I simply implement a strongly typed POST edit action method and receive a fully populated ViewModel as a parameter like this:

//POST: /CustomersController/Edit

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Edit(CustomersFormViewModel model)
{
//validate data, save customer, handle validation errors...
}

The answer is yes! The MVC framework even maps object hierarchies of any depth as ViewModels.

How not to do it

This is all really easy, but still there were few things that threw me off at the beginning.

The ViewModelBinder only maps properties, not public fields. A ViewModel like this cannot be mapped:

public class CustomersFormViewModel
{
public electList AccountTypes;
public SelectList Countries;
public Customer Customer;
}

The names of your POSTed form values must match the object hiearchy you want them to be mapped to. Something like this will not work:

<p></p></p></p></p></p></p></p></p></p></p>

<label for="FirstName">

FirstName:</label><br />

<%= Html.TextBox("FirstName",Model,Customer,FirstName)%>

<%= Html.ValidationMessage("FirstName", "*")%>

</p>

In hindsight both restrictions are perfectly logic and reasonable, but it’s easy enough to do it wrong nevertheless and also quite difficult to figure out what went wrong if binding does not work. Hopefully this article will help you avoid any problems with using Custom ViewModels with POST action methods.

It seems there are no good books available on the subject yet. The few that are already in stock at Amazon are based on the community preview, and it seems that there have been quite a few changes in the the framework since then.

Fortunately, ScottGu hat just released a free sample chapter of his upcoming “Professional ASP.NET” (Wrox) book. It contains a 200-page walkthrough guide on how to build a simple ASP.NET MVC application.

The chapter is available for download here.