Razor View Engine

The Razor view engine is a new view engine option for ASP.NET MVC that supports the Razor templating syntax. The Razor syntax is a streamlined approach to HTML templating designed with the goal of being a code driven minimalist templating approach that builds on existing C#, VB.NET and HTML knowledge. The result of this approach is that Razor views are very lean and do not contain unnecessary constructs that get in the way of you and your code.

ASP.NET MVC 3 Preview 1 only supports C# Razor views which use the .cshtml file extension. VB.NET support will be enabled in later releases of ASP.NET MVC 3. For more information and examples, see Introducing “Razor” – a new view engine for ASP.NET on Scott Guthrie’s blog.

Dynamic View and ViewModel Properties

A new dynamic View property is available in views, which provides access to the ViewData object using a simpler syntax. For example, imagine two items are added to the ViewData dictionary in the Index controller action using code like the following:

public ActionResult Index() {
         ViewData["Title"] = "The Title";
         ViewData["Message"] = "Hello World!";
}

Those properties can be accessed in the Index view using code like this:

<h2>View.Title</h2>
<p>View.Message</p>

There is also a new dynamic ViewModel property in the Controller class that lets you add items to the ViewData dictionary using a simpler syntax. Using the previous controller example, the two values added to the ViewData dictionary can be rewritten using the following code:

public ActionResult Index() {
    ViewModel.Title = "The Title";
    ViewModel.Message = "Hello World!";
}

“Add View” Dialog Box Supports Multiple View Engines

The Add View dialog box in Visual Studio includes extensibility hooks that allow it to support multiple view engines, as shown in the following figure:



Service Location and Dependency Injection Support

ASP.NET MVC 3 introduces improved support for applying Dependency Injection (DI) via Inversion of Control (IoC) containers. ASP.NET MVC 3 Preview 1 provides the following hooks for locating services and injecting dependencies:

- Creating controller factories.
- Creating controllers and setting dependencies.
- Setting dependencies on view pages for both the Web Form view engine and the Razor view engine (for types that derive from ViewPage, ViewUserControl, ViewMasterPage, WebViewPage).
- Setting dependencies on action filters.
Using a Dependency Injection container is not required in order for ASP.NET MVC 3 to function properly.

Global Filters

ASP.NET MVC 3 allows you to register filters that apply globally to all controller action methods. Adding a filter to the global filters collection ensures that the filter runs for all controller requests. To register an action filter globally, you can make the following call in the Application_Start method in the Global.asax file:

GlobalFilters.Filters.Add(new MyActionFilter());

The source of global action filters is abstracted by the new IFilterProvider interface, which can be registered manually or by using Dependency Injection. This allows you to provide your own source of action filters and choose at run time whether to apply a filter to an action in a particular request.

New JsonValueProviderFactory Class

The new JsonValueProviderFactory class allows action methods to receive JSON-encoded data and model-bind it to an action-method parameter. This is useful in scenarios such as client templating. Client templates enable you to format and display a single data item or set of data items by using a fragment of HTML. ASP.NET MVC 3 lets you connect client templates easily with an action method that both returns and receives JSON data.

Support for .NET Framework 4 Validation Attributes and IvalidatableObject

The ValidationAttribute class was improved in the .NET Framework 4 to enable richer support for validation. When you write a custom validation attribute, you can use a new IsValid overload that provides a ValidationContext instance. This instance provides information about the current validation context, such as what object is being validated.
This change enables scenarios such as validating the current value based on another property of the model. The following example shows a sample custom attribute that ensures that the value of PropertyOne is always larger than the value of PropertyTwo:

public class CompareValidationAttribute : ValidationAttribute {
    protected override ValidationResult IsValid(object value,
             ValidationContext validationContext) {
        var model = validationContext.ObjectInstance as SomeModel;
        if (model.PropertyOne > model.PropertyTwo) {
           return ValidationResult.Success;
        }
        return new ValidationResult("PropertyOne must be larger than PropertyTwo");
    }
}

Validation in ASP.NET MVC also supports the .NET Framework 4 IValidatableObject interface. This interface allows your model to perform model-level validation, as in the following example:

public class SomeModel : IValidatableObject {
    public int PropertyOne { get; set; }
    public int PropertyTwo { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext) {
        if (PropertyOne <= PropertyTwo) {

           yield return new ValidationResult(
               "PropertyOne must be larger than PropertyTwo");
        }
    }
}

New IClientValidatable Interface

The new IClientValidatable interface allows the validation framework to discover at run time whether a validator has support for client validation. This interface is designed to be independent of the underlying implementation; therefore, where you implement the interface depends on the validation framework in use. For example, for the default data annotations-based validator, the interface would be applied on the validation attribute.
Support for .NET Framework 4 Metadata Attributes
ASP.NET MVC 3 now supports .NET Framework 4 metadata attributes such as DisplayAttribute.

New IMetadataAware Interface

The new IMetadataAware interface allows you to write attributes that simplify how you can contribute to the ModelMetadata creation process. Before this interface was available, you needed to write a custom metadata provider in order to have an attribute provide extra metadata.
This interface is consumed by the AssociatedMetadataProvider class, so support for the IMetadataAware interface is automatically inherited by all classes that derive from that class (notably, the DataAnnotationsModelMetadataProvider class).

New Action Result Types

In ASP.NET MVC 3, the Controller class includes two new action result types and corresponding helper methods.

HttpNotFoundResult Action

The new HttpNotFoundResult action result is used to indicate that a resource requested by the current URL was not found. The status code is 404. This class derives from HttpStatusCodeResult. The Controller class includes an HttpNotFound method that returns an instance of this action result type, as shown in the following example:

public ActionResult List(int id) {
    if (id < 0) {
                return HttpNotFound();
    }
    return View();
}

HttpStatusCodeResult Action

The new HttpStatusCodeResult action result is used to set the response status code and description.

Permanent Redirect

The HttpRedirectResult class has a new Boolean Permanent property that is used to indicate whether a permanent redirect should occur. A permanent redirect uses the HTTP 301 status code. Corresponding to this change, the Controller class now has several methods for performing permanent redirects:

- RedirectPermanent
- RedirectToRoutePermanent
- RedirectToActionPermanent

These methods return an instance of HttpRedirectResult with the Permanent property set to true.

Breaking Changes

The order of execution for exception filters has changed for exception filters that have the same Order value. In ASP.NET MVC 2 and earlier, exception filters on the controller with the same Order as those on an action method were executed before the exception filters on the action method. This would typically be the case when exception filters were applied without a specified order Order value. In MVC 3, this order has been reversed in order to allow the most specific exception handler to execute first. As in earlier versions, if the Order property is explicitly specified, the filters are run in the specified order.

Known Issues

When you are editing a Razor view (CSHTML file), the Go To Controller menu item in Visual Studio will not be available, and there are no code snippets.