Take advantage of the powerful features in ASP.NET MVC to build robust applications with ease.

This article takes a look at the 10 best practices that can be followed for best and efficient use of ASP.NET MVC Framework 4.

Pre-requisites

As of this writing, ASP.NET MVC 4 has been released. To execute the code examples illustrated in this article, you should have the following installed in your system:

• ASP.NET MVC 4
• Visual Studio 2010

What is the ASP.NET MVC Framework?

The ASP.NET MVC Framework is based on the popular and time tested Model View Controller (MVC) Design Pattern. It facilitates designing and implementing applications where you can have a cleaner separation of concerns, better code organization, seamless testability, easy extensibility, scalability and code reuse.

The Official ASP.NET Website states: "The Model-View-Controller (MVC) architectural pattern separates an application into three main components: the model, the view, and the controller. The ASP.NET MVC framework provides an alternative to the ASP.NET Web Forms pattern for creating MVC-based Web applications. The ASP.NET MVC framework is a lightweight, highly testable presentation framework that (as with Web Forms-based applications) is integrated with existing ASP.NET features, such as master pages and membership-based authentication. The MVC framework is defined in the System.Web.Mvc namespace and is a fundamental, supported part of the System.Web namespace." Reference: http://www.asp.net/mvc/tutorials/overview/asp-net-mvc-overview

If you want to upgrade your ASP.NET MVC 3 applications to ASP.NET 4, here’s what you would need to do:

Locate the following text in the application's web.config file:

• System.Web.Mvc, Version=3.0.0.0
• System.Web.WebPages, Version=1.0.0.0
• System.Web.Helpers, Version=1.0.0.0
• System.Web.WebPages.Razor, Version=1.0.0.0

Now, replace the above with the following text:

• System.Web.Mvc, Version=4.0.0.0
• System.Web.WebPages, Version=2.0.0.0
• System.Web.Helpers, Version=2.0.0.0,
• System.Web.WebPages.Razor, Version=2.0.0.0,

Delete all references to the following assemblies in your application:

• System.Web.Mvc (v3.0.0.0)
• System.Web.WebPages (v1.0.0.0)
• System.Web.Razor (v1.0.0.0)
• System.Web.WebPages.Deployment (v1.0.0.0)
• System.Web.WebPages.Razor (v1.0.0.0)

Add references to the following assemblies:

• System.Web.Mvc (v4.0.0.0)
• System.Web.WebPages (v2.0.0.0)
• System.Web.Razor (v2.0.0.0)
• System.Web.WebPages.Deployment (v2.0.0.0)
• System.Web.WebPages.Razor (v2.0.0.0)

Top 10 Best Practices

In this section we will discuss 10 best practices and tips we should keep in mind when working with ASP.NET MVC applications.

Tip 1: Disable Request Validation

Request Validation is a feature that prevents potentially dangerous content from being submitted. This feature is enabled by default. However, at times you might need your application to post HTML markup tags to the server. You would then need this feature to be disabled. Here is how you can do it:

[ValidateInput(false)]
[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Create([Bind(Exclude="Id")]Employee empObj)
{

}

Tip 2: Cache Your Data

You can improve your application's performance to a considerable extent by caching relatively stale data. That way the network bandwidth between the client and the server is also reduced. It is great if you can also cache the rendered action of web pages that are relatively stale, i.e., don’t change much over time.

public class HomeController : Controller
{
    [OutputCache(Duration=3600,
VaryByParam="none")]
    public ActionResult Index()
    {
     
    }
}

Tip 3: Isolate Data Access Logic From the Controller

The Controller in an ASP.NET MVC application should never have the Data Access logic. The Controller in an ASP.NET MVC application is meant to render the appropriate view based on some user interface action. You should make use of Repository Pattern to isolate Data Access Logic from the Controller – you might need dependency injection to inject the appropriate Repository to your controller at runtime.

Tip 4: Using a Master View Model

We frequently use Master Pages in ASP.NET applications – the same Master Page would be extended by the Content Pages throughout the application to give a similarity as far as look and feel and functionality is concerned. How do we do that in an ASP.NET MVC application? Well, we need a MasterViewModel similar to what is shown in the code snippet below:

public class ViewModelBase
{
    public ViewModelBase()
    {

    }
//Other methods and properties
}

Tip 5: Use Strongly Typed Models

A strongly typed view is a view that defines its data model as a CLR type instead of a weakly typed dictionary that may contain potentially anything. To create a strongly typed view, check the "Create a strongly-typed view" checkbox while you are creating the view. If you plan to create a strongly typed view manually later, ensure that your view "Inherits" System.Web.Mvc.<Your Namespace>.<YourClass>

Tip 6: Use Data Annotations for Validation

You can make use of the System.ComponentModel.DataAnnotations assembly to validate your server - side code by simply decorating your model with the necessary attributes. Here is an example:

public class Employee
{
    [Required(ErrorMessage="Employee Name Cannot be Blank")]
    public string Name { get; set; }

    // ...
}

Tip 7: Take Advantage of Model Binding

Consider the following code snippet:

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Create()
{
    Employee employee = new Employee();
    employee.Name = Request.Form["Name"];
    
    // ...
    
    return View();
}

You can make use of model binder to save you from having to use the Request and HttpContext properties - just use FormsCollection instead. Here is an example:

public ActionResult Create(FormCollection values)
{
    Employee employee = new Employee();
    employee.Name = values["Name"];      
            
    // ...
            
    return View();
}

Tip 8: Cache Pages that Contain Shared Data or are Public and don't Require Authorization

You should not cache pages that need authorization in ASP.NET MVC. You should not cache pages that contain private data or need authorization. Caching pages in ASP.NET MVC is simple - just specify the OutputCache directive as shown in the code snippet below:

[OutputCache(Duration = 60)]
public ActionResult Index()
{
  return View("Index", somedata);
}

Tip 9: Use Extension Methods

You can make use of Extension Methods to simplifies use of LINQ queries that boost application performance too. This can dramatically reduce the amount of code that you would need to otherwise write when writing your LINQ queries, make your LINQ queries manageable and also improve the application's performance.

Tip 10: Take Advantage of Model Binding

You can take advantage of Microsoft Velocity - a distributed caching engine to boost the application performance of your ASP.NET MVC applications. You can learn more on Velocity from this link: http://blogs.msdn.com/b/velocity/

Suggested Readings

http://www.asp.net/mvc

Summary

Scott Guthrie states in his blog: “One of the benefits of using an MVC methodology is that it helps enforce a clean separation of concerns between the models, views and controllers within an application. Maintaining a clean separation of concerns makes the testing of applications much easier, since the contract between different application components are more clearly defined and articulated.” Reference: http://weblogs.asp.net/scottgu/archive/2007/10/14/aspnet-mvc-framework.aspx

In this article we discussed the top 10 best practices that we should follow while using ASP.NET MVC Framework 4 applications. Happy reading!