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.
