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.
