Fredrik Normén : MVC Framework

What role does the User Control has in the ASP.Net MVC?

Fredrik N — Fri, 28 Nov 2008 08:28:00 GMT

Several developers have asked me about the use of User Controls within the ASP.Net MVC, so I decided to write down what I think about it.

A User Control is a piece of the User Interface which is sometimes created to be reused on several of Web Forms, some are created as a result from a Refactoring of the User Interface code. A User Control has a code-behind and the User Control is living its own life mostly if the Web Form and User Control is well defined. Some people tend to access the Web Form from a User Control and I think that is bad practice, it will make the User Control dependent to a specific Web Form, so a better solution is to use events which a Web Form can subscribe to, if we need to pass data from the Web Form to the User Control, we can do it by adding properties to the User Control. Now how about a User Control in the ASP.Net MVC?

As you all may know there is a View and the View has a Controller, the Controller work like a contract between the View and the Model. The Model is where we have our Business Logic and domain entities.

NOTE! I have seen several developers using the Controllers as a replacement of Business object, that is not the role of a Controller, the Business logic should be in the Model.

I will assume that a View has only one Controller and should only be dependent on one, so in the ASP.Net MVC the User Controls will take a "new" kind of role. A User Control in the ASP.Net MVC is part of the View and should reuse the same Controller as the View. If not, our View will have dependency to several different Controllers and we will need to take this into consideration when writing our test. We should try to avoid as many dependency as possible, too many dependency will make the code harder to read and maintain etc. So what role does the User Control take in a View? They will be a result of Refactoring of the User Interface code, and will more or less be like a simple "include" file used by the VIew (Like a extracted method in a Class). A User Control and a View together will create a complete View and this complete View should only work against one Controller. Some developers tend to create and use a User Control after the same pattern they are used to when they work with Web Forms. Instead of using a code-behind, they bind the User Control to it's own Controller. By doing so, a View which will use the User Control, will have a indirect dependency to several Controllers. Instead of making sure a View has its own Controller, it now has several, if we have several User Controls on the same View and all User Controls uses their own Controllers, we will sooner or later create a Death Star. If we should use a User Control in the ASP.Net MVC it's the Controller of the View which will return the Model which the User Control and View will use, right?! So it's the same Controller that should handle the User Controls actions. If we want to create a User Control and see it as a self lived unit, I think it should be important to let its own Controller give the Model to the User Control, but how it's designed today, we can't. It's the Controller used by the View which must also get the Model for the User Control.

How about reusing a User Control on different Views if they should more or less serve as a "include" file and use the same Controller as the View? For me it's all fine, because the User Control will share the same Controller as the View, and the User Control should try to avoid having its own form element. If we want to reuse a User Control on several of Views, where the User Control has its own Controller, the Controller of the View will have a indirect dependency to the User Control and suddenly the Controller of a View will have several reason to change (If the User Control need to be updated and that may lead to an update of the Controller.). To solve this, we shouldn't try to reuse a User Control as long as it can't server as a simple include of HTML element, where the User Control will not have a form element pointed to a separate Controller served only by the User Control.

I hope some of you can try to convince me if my assumptions is totally wrong, or at least you can try ;)

MVC, ASP.NET

ASP.Net MVC Framework - How do I design my apps with the MVC pattern and +P

Fredrik N — Tue, 22 Apr 2008 20:36:00 GMT

When I'm playing around with the ASP.NET MVC Framework I have created several prototype applications with different solutions to solve some "problems." In this post I will write down how I combine a Presentation Model (When I talk about Presentation Model in this post, I refer to a model which purpose is only to define a model for presentation purpose) with the MVC, it's what the P in MVC+P stands for.

When I build apps today I use Domain Driven Design and I use the MVC pattern in some of my web based applications. As many of you know the M in MVC stands for the Model and contains our entities, business logic can data access components. Often when I build my apps with the ASP.Net MVC Framework (still only use in as a prototype because the framework is under development) I create my own custom Controller Factory to support Dependency Injection (DI). For example I use constructor injection or setter injection to inject my Repositories or manual injection of Mock objects during test. I use Spring.Net as my DI framework because it’s the framework I like the most.

Here is a simple example how my Controllers can look like and are prepared for constructor injection:


public class HomeController : Controller
{
    ICompanyRepository _companyRepository;

    public HomeController() : this(new CompanyRepository()) { }

    public HomeController(ICompanyRepository companyRepository)
    {
        this._companyRepository = companyRepository;
    }

    public ActionResult Index()
    {
        CompanyInfo companyInfo = this._companyRepository.GetCompanyInfo();
        return RenderView("Index", companyInfo);
    }
}

As you can see I create an instance of a CompanyRepository in the default constructor, the reason to this is because if I create a normal instance of the HomeController, I want it to use a default Repository. I also have a constructor which takes a ICompanyRepository as an argument, this is because to enable constructor injection. I can use the constructor to pass in my Mock object of the CompanyRepository, or I can use Spring.Net to inject a ICompanyRepository, which I use in my own custom Controller Factory. Here is how my test could look like where I have a Mock object for the CompanyRepository:

    MockCompanyRepository mockCompanyRepository = new MockCompanyRepository();

    mockCompanyRepository.Create(new CompanyInfo("........"));

    CompanyController companyController = new CompanyController(mockCompanyRepository);

    var result = CompanyController.Index() as RenderViewResult;

    //Assert...

Note: If you have read my Step by Step Guide, I use the LINQ to SQL's DataContext object directly in my Controllers, it's because they can sometimes serve as a "Repository" because the power of the LINQ.

When I use MasterPage which should always render a part of my Model, like content for a Menu etc, or when I need to render more than one entities of my Model, I need to make sure my Controllers will fill the ViewData property with more information than just one single entity from my Model. In this case I may have several Repositories which I need to call from my Controllers. If I use constructor injection, I need to add an argument to a Controller's constructor for each Repository. This can make the constructor cumbersome. To solve the issue and reduce the number of argument, I instead use setter injection, so I inject the Repositories needed through a set method (using properties). By doing this I can easy manually inject my Mock objects in my test:

    MockCompanyRepository mockCompanyRepository = new MockCompanyRepository();
    MockCustomerRepository mockCustomerRepository = new MockCustomerRepository();

    //...

    CompanyController companyController = new CompanyController();

    companyController.CompanyRepository = mockCompanyRepository;
    companyController.CustomerRepository = mockCustomerRepository;

    var result = CompanyController.Index() as RenderViewResult;

    //Assert...

I can still reuse my own custom Controller Factory without changes to support setter injection, because I simple only let Spring.Net know that I want to inject my Repositories by using setter injection. When I use setter injection, I don't create an instance of the default Repository or Repositories in the default constructor of the Controller.

The following is an example of a Controller which uses to Repositories and pass two entities to the "View":

public class HomeController : Controller
{
    ICompanyRepository _companyRepository;
    ICustomerRepository _customerRepository;

    public HomeController() { }


    public ActionResult Index()
    {
        ViewData["CompanyInfo"] = this.CompanyRepository.GetCompanyInfo();
        ViewData["Customer"] = this.CustomerRepository.GetCustomer();
        
        return RenderView();
    }

    
    public ICustomerRepository CustomerRepository
    {
        get
        {
            if (this._customerRepository == null)
                this._customerRepository = new CustomerRepository();

            return this._customerRepository;
        }
        set
        {
            this._customerRepository = value;
        }
    }


    public ICompanyRepository CompanyRepository
    {
        get
        {
            if (this._companyRepository == null)
                this._companyRepository = new CompanyRepository();

            return this._companyRepository;
        }
        set
        {
            this._companyRepository = value;
        }
    }

}

The Index method will now return two entities. Assume the CompanyInfo is for the MasterPage and the Customer for the Content Page. The ViewData property in this case will sort of be a Presentation Model ("The essence of a Presentation Model is of a fully self-contained class that represents all the data and behavior of the UI window") but don't contain any behavior.

Something that can make the above Controller or other Controllers ugly and start to smell, is when most action method must set the ViewData for the Model which the MasterPage will render. There is a tiny little problem regarding to how I will work and think when it comes to Test Driven Developement, when I use a MasterPage or User Controls on a View which will render different models. The problem is, when I create a test for a Controller before the Controller is implemented, I must know about what Models the UI will render, all entity objects even for the MasterPage and User Controls. I can't only assume that the CustomerController's List action method will return a list of Customers, I also need to have in mind the model the MasterPage and User Controls will use and when writing the test. Well basically I can ignore it, but it can affect how my ViewData will look like, and what key I need to use to get access to my list of Customers etc. This is something that I don't want to care about for every action method I want to create a test for. I also like the way I can type the ViewData property for the View. To solve the issue I decided to create a base class called PresentationModel. This class have one typed property for the model the MasterPage should render, MasterPageModel and one for the Repository which will get the Model for the MastePage, here is an example:

public class PresentationModel
{
    private CompanyInfo _companyInfo;

    public CompanyInfo MasterPageModel
    {
        get
        {
            if (this.CompanyRepository == null)
                throw new ApplicationException("A ICompanyRepository must be set");

            if (this._companInfo == null)
                this._companyInfo = this.CompanyRepository.GetCompanyInfo();

            return this._companyInfo;
        }
        set
        {
            this._companyInfo = value;
        }
    }

    public ICompanyRepository CompanyRepository { get; set; }
}

If the Model or the MasterPage is changed and that affect what the MastePage should render, I only need to change what model the PresentationModel class returns through the MastePageModel property, I don't need to go through all action methods and update them. That is one benefit with this design solution.

Note: I use a property for the CompanyRepository to make it easy to add a Mock object in my tests.

The PresentationModel is the type I specify for the MastePage to make it typed.

public partial class Site : System.Web.Mvc.ViewMasterPage<PresentationModel>
{
}

I then create a sub class of the PresentationModel called GenericPresentationModel. The GenericPresentaionModel class is a generic class which inherits from the PresentationModel and have a generic property called Model.

public class GenericPresentationModel<T> : PresentationModel
{
    public GenericPresentationModel() {}

    public GenericPresentationModel(T model)
    {
        this.Model = model;
    }

    public T Model { get; set; }
}

The Controllers can now use the GenericPresentationModel and pass it to the View, the following Controller has an Action method which will render a Customer:


public ActionResult Index()
{
    Customer customer = this.CustomerRepository.GetCustomer();

    var presentationModel = new GenericPresentationModel<Customer>(customer);

    return RenderView("Index", presentationModel);
}

Because I pass the GenericPresentationModel to my View, I can also type the View:

public partial class CustomerView : ViewPage<GenericresentationModel<Customer>>
{
}

Then my ViewData property of my View will be of Type GenericPresentationModel<Customer>. So I can easy get access to my Customer by using ViewData.Model.

The following example shows how the test of an Action which will render a Customer could look like:


        MockCustomerRepository mockCustomerRepository = new MockCustomerRepository();

        //...

        HomeController controller = new HomeController();
        controller.CustomerRepository = mockCustomerRepository();

        var result = controller.Index() as RenderViewResult;

        var presentationModel = result.ViewData as GenericPresentationModel<Customer>;

        //Assert.....

Because I don't use the MastePageModel property in my test of the Index method, I don't need to inject the Mock Repository for the PresentationModel base class. When I created the PresentationModel I have already created a test to make sure the PresentationModel returns the correct data, so I don't need to care about testing that again in my other tests.

I still use this approach in a prototype solution to see how well it will work. When I work with Domain Driven Design I often need to render different information from different entities from my domain model. In my case I don't always want to pass several entities to my Views, so instead I create new object that will combine information from different entities, with another word, I create a Presentation Model. Most larger apps which I have created with the ASP.Net MVC Framework, often result in the use of a Presentation Model, and that is the P in the MVC+P. I know that several people don't like this because it requires us to create a lot of extra classes, but the benefits is that the Views will use the Presentation Model and don't even need to know about the domain model. If we don't pass a single entity from our domain model to the View, instead we use a Presentation Model and map the domain model to the Presentation Model, we can change the domain model, and it doesn't need to change the Views, only the mapping between the Presentation Model and the domain model. To be honest I don't create a complete Presentation Model, I still pass entities from the domain model to the View, mostly to keep it simple and not spend extra time to write new classes for each View.

I'm interested about what you think, how you solve similar problems, do you use similar solutions that I do and have notice problems that I haven't notice yet, please let me know.

ASP.Net MVC Framework pre- Preview 3 - A Step by Step guide to create a simple web app.

Fredrik N — Thu, 17 Apr 2008 10:00:00 GMT

Yesterday I posted a step by step guide by using the Preview 2 of the ASP.Net MVC Framework, the following is an updated version that targets the pre-release of the Preview 3 version of the ASP.Net MVC Framework.

In this post you will learn how to use most of the new features in the pre-release of the Preview 3 version of the ASP.NET Framework, you will also get a basic understanding about how to use LINQ to SQL. This step by step guide shouldn't be used as a "best way to create and design" a web applications by using the ASP.NET MVC Framework, this guide should only be used to get started with the MVC Framework in a fast and easy way and learn different ways to use some of the features shipped with the ASP.Net MVC Framework pre-release Preview 3.

To get the pre-release version, you can download it from here.

In this step by step guide you are going to create a web based application where you will be able to list and modify customers. This step by step guide will use C# 3.0 and the Northwind database.

1. Open Visual Studio 2008

2. Create a new Project and select the ”ASP.NET MVC Web Project” project from the "My Template" section and name it to “CustomerApp”.

3. Open global.asax and walk through the code. In Global.asax you can specify your routes. In this step by step guide you will use the default settings.

routes.MapRoute(
               "Default",                                              // Route name
               "{controller}/{action}/{id}",                           // URL with parameters
               new { controller = "Home", action = "Index", id = "" }, // Parameter defaults
               new { controller = @"[^\.]*" }                          // Parameter constraints
           );

As you can see, there is a new method added to the RouteCollection, MapRoute. This method can be used to make the configuration of routing more cleaner. You can still use the old way with the Route object.

The first thing to do is to create your business objects (your Model) which your Controllers will interact with. In this step by step guide you will use LINQ to SQL, even if it’s not advisable to generate domain models out from a data source you will learn how to do it, only to get up and running fast.

Note: The business objects belongs to the Model in the MVC pattern.

4. Right click on the Models folder in the Solution Explorer and select Add > New Item.

Select the “LINQ to SQL Classes” template and name the file to “Northwind.dbml” and press the Add button.

To create your Model out from a data source you need to add a database connection to Visual Studio. This can be done by using the Server Explorer. In the Solution Explorer, right click on the Data Connections node and select Add Connection. Enter the following information to connect to the Northwind database:

Server Name: (local)

Select the Northwind database, test the connection and press OK if you were able to connect to the database.

A connection to the Northwind database will now be added under the “Data Connections” node in the Server Explorer. Expand the database and the Tables nodes; drag out the Customer table into the design view of the Northwind.dbml file. Save the file. When you save the file, LINQ to SQL will generate a Customer object for you where the columns from the Customers table will be added as properties to the Customer object. LINQ to SQL will also generate a DataContext object (NorthwindDataContext) which you will use later to access your information from the data source. Expand the Northwind.dbml file in the Solution Explorer, double click on the Northwind.designer.cs file and walk through the code. LINQ to SQL uses attributes to map classes to a table.

Now it’s time to create the Controller which you are going to use in this application.

5. Right click on the Controllers folder in the Solution Explorer and add a new item and select the “MVC Controller Class” template from the "My Templates" section, name it to “CustomerController”.

6. Add a private field of the type NorhwindDataContext to the Controller and name the field to “northwindDataContext”. Set the field to an instance of the NorthwindDataContext object.

Note: The NorthwindDataContext class will exist in the CustomerApp.Models namespace.


using CustomerApp.Models;

namespace CustomerApp.Controllers
{
    public class CustomerController : Controller, IDisposable
    {
        private NorthwindDataContext northwindDataContext = new NorthwindDataContext();
       
        //...
    }
}

7. Make sure the CustomerController implements the IDisposable interface, and implement the Dispose method and make sure it will make a call to the northwindDataContext’s Dispose method. This will make sure the NorthwindDataContext’s Dispose method will be called when the Controller have been used.


public class CustomerController : Controller, IDisposable
{
    private NorthwindDataContext northwindDataContext = new NorthwindDataContext();
   
    //...
    
    public void Dispose()
    {
        this.northwindDataContext.Dispose();
    }
}

8. Add an Action method and name it to “List”. The List action will retrieve all Customers from the Customers table of the Northwind database. LINQ to SQL will be used to get all the Customers, order the Customers by CompanyName. When all customers are retrieved make sure to render a View with the name “Customers” (The View will be added later to the project), the View should render a generic list of Customer objects.


public ActionResult List()
{
    List<Customer> customers = (from customer in northwindDataContext.Customers
                                orderby customer.CompanyName
                                select customer).ToList();

    return RenderView("Customers", customers);
}

There are some changes to the Action methods between the Preview 2 and pre-release of Preview 3 of the ASP.Net MVC Framework. An Action method now returns a ActionResult. The RenderView method will now return a RenderViewResult, which inherits the ActionResult class. The changes are made to make it easier to create unit test without needing to create a lot of Mock objects, and also to make it easier in the future to support async. programming etc. You can read more about it on Scott Guthire's blog.

Note: By default if we make a call to RenderView, without passing the name of the View, it will use the name of the Action method as the View to render.

The following example shows an example of how a unit test can look like to test the List action method:


[TestClass]
public class CusomerControllerTest
{
    [TestMethod]
    public void ListCustomerTest()
    {
        CustomerController custController = new CustomerController();

        var result = custController.List() as RenderViewResult;

        Assert.IsNotNull(result, "Expected a RenderViewResult");

        var customers = result.ViewData as List<Customer>;
        
        Assert.IsNotNull(result.ViewName, "Customers", "...");
        Assert.IsNotNull(customers, "...");
        //...
    }
}

Note: There is a helper method of the Controller base class called Redirect, which can be used to do a redirect within a Action method. The Redirect method returns a HttpRedirectResult, which inherits from the ActionResult class. The RedirectToAction method now returns an ActionRedirectResult class.

9. Create a View with the name “Customers” which will render the generic list of Customer objects. To add a View, right click on the Views folder and add a new folder with the name “Customer”. Right click on the Customer folder and add a new item, select the “MVC View Page” template from the "My Template" section and name the View to “Customers”. Make sure the View data inherits from ViewPage<List<CustomerApp.Models.Customer>>. This will make sure the Model which is passed as an argument to the RenderView method is a known and typed for the View. Open the file Customers.aspx.cs file, replace so the page inherits from ViewPage<List<CustomerApp.Models.Customer>> instead of ViewPage.


public partial class Customers : ViewPage<List<CustomerApp.Models.Customer>>
{
}

10. Add code to render a list of Customers to the View, make sure the CustomerID and ContactName are listed. Open the Customer.aspx file, add an inline-code block and use foreach to iterate through the Customers, use the ViewData property to get access to the generic list of Customer objects.


<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customers.aspx.cs" Inherits="CustomerApp.Views.Customer.Customers" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <div>
        <table>
        <% foreach ( var customer in ViewData) { %>
            <tr>
                <td><%=Html.Encode(customer.CustomerID) %></td>
                <td><%=Html.Encode(customer.ContactName) %></td>
            </tr>
        <% } %>
        </table>
    </div>
</body>
</html>

Make sure you have saved all files, compile and run the application. To the end of the URL add “Customer/List” and press enter. The URL will look something like this: http://localhost:<port number>/Customer/List.

Your application will now make sure the Controller “CustomerController” will be used and also the Action method “List” will be invoked. If everything works, you will now see a list of CustomerID and ContactName.

Note: The route that was defined in global.asax looks like this:

{controller}/{action}/{id}

When you enter a URL like “Customer/List”, the Customer will be the name of the Controller to be used, and the List the name of the Action method to be executed, the id in the route will be empty and will be ignored.

11. Add a new Action method to the CustomerController and name it to “View”. The View method should have one argument with the name ID and the type of String. Make sure the method will use LINQ to SQL to get a Customer from the Customers table which matches the CustomerID passed as an argument. If a customer is not found, use the Redirect method and navigate to "/Errors/CustomerNotFound/<customer ID>". Make sure to render a View with the name “Customer”. The View should render a detail view of a Customer.

public ActionResult View(string ID)
{
    Customer customer = (from c in northwindDataContext.Customers
                         where c.CustomerID == ID
                         select c).FirstOrDefault();

    if (customer == null)
        return Redirect("/Error/CustomerNotFound/" + ID);

    return RenderView("Customer", customer);
}

Note: You will not implement a Controller or Views that will handle the error in this guide, it is used to demonstrate the Redirect method, and also how you can create a unit test that can check that the Action do the right thing when a CustomerID is passed to the Action method, and the customer can't be found.

The following example will show you for example how you can write a test that will check if the user can't be found and that the Action method will do a Redirect:


[TestMethod]
public void ViewCustomerTest_Cant_Found_Customer()
{
    CustomerController custController = new CustomerController();

    var result = custController.View("Unknow Id") as HttpRedirectResult;

    Assert.IsNotNull(result, "Expected a http redirect");

    //...
}

Because the Redirect method returns a HttpRedirectResult, you can in your Unit test, see if the Action method will do a Redirect or not.

12. Add a new View to the Views/Customer folder and name it “Customer”. Make sure the Customer View will inherit form the ViewPage<CustomerApp.Models.Customer> class.


public partial class Customer : ViewPage<CustomerApp.Models.Customer>
{
}

13. Open the Customer.aspx page and add inline-code block to show detail information about a Customer, make sure input text elements is used to display the content of the Customer (you will later in the lab update the Customer). Set the name attribute of the input text element to the same name as the property of the Customer object it should display. The CustomerID should be displayed as a simple text, and also be a value of an input hidden field with the name “CustomerID”. The reason why you will use a hidden field with the CustomerID, is because you will later use the MVC Frameworks “databinding” feature.

Note: The Customer object has several properties, and to make this lab simple you can only use some of them, CustomerID, CompanyName, ContactName and Phone.

Leave the <Form> elements action attribute empty at the moment.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customer.aspx.cs" Inherits="CustomerApp.Views.Customer.Customer" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <form method="post" action="">
        <table>
            <tr>
                <td>Customer ID:</td>
                <td><%= Html.Encode(ViewData.CustomerID) %></td>
            </tr>
            <tr>
                <td>Company name:</td>
                <td><input type="text" name="CompanyName" value="<%= Html.Encode(ViewData.CompanyName) %>" /></td>
            </tr>
            <tr>
                <td>Contact Name:</td>
                <td><input type="text" name="ContactName" value="<%= Html.Encode(ViewData.ContactName) %>" /></td>
            </tr>
            <tr>
                <td>Phone:</td>
                <td><input type="text" name="Phone" value="<%= Html.Encode(ViewData.Phone) %>" /></td>
            </tr>

        </table>

        <input type="hidden" name="CustomerID" value="<%= Html.Encode(ViewData.CustomerID) %>" />
        
    </form>
</body>
</html>

Note: Instead of writing the whole <input> element, you can also use the Html help method:


<%= Html.TextBox("CompanyName", ViewData.CompanyName) %>

This method will render the following output:

<input type=”text” size=”20” name=”CompanyName” id=”CompanyName” value=”My Company”/>

Writing HTML will give you more control over the HTML which will be sent to the client.

Save your View and build your solution. Start the application and to the end of the URL enter “Customer/View/ALFKI”. The URL will look something like this: http://localhost:<port number>/Customer/View/ALFKI. The Customer controller will be used and its Action method View will be called based on the route in global.asax the value after the specified Action method will be passed as an argument to the specified Action method. The argument is mapped to the argument with the name “ID”.

If everything works, you will now see a detail view over the Customer with the CustomerID “ALFKI”.

14. Open the Customers.aspx View and make sure the listed CustomerID instead will be a HyperLink, which will have the following URL pattern: “/Customer/View/<CustomerID>”.


<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customers.aspx.cs" Inherits="CustomerApp.Views.Customer.Customers" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <div>
        <table>
        <% foreach ( var customer in ViewData) { %>
            <tr>
                <td>
                <a href="/Customer/View/<%=customer.CustomerID %>"><%=customer.CustomerID %></a>
                </td>
                <td><%=Html.Encode(customer.ContactName) %></td>
            </tr>
        <% } %>
        </table>
    </div>
</body>
</html>

Instead of writing the <a> element you can use the Html helper method to let it create an RouteLink, for example like this:


<%=Html.RouteLink(ViewData.CustomerID, "Default", new { ID = ViewData.CustomerID, Controller="Home", Action="View" }) %>

When you use the MapRoute method to create a route in global.asax, you give the route a name, for example the default route has the name "Default". When you use the RouteLink method, you can specify the name of the route, the RouteLink method generates a HyperLink. The example above will use the Default route. The result of the above example will be:

<a href="http://weblogs.asp.net/Home/View/AFLK">AFLK</a>

Note: In a future release of the MVC Framework, you don't need to pass the Controller and the Action to the RouteLink.

If everything works correct, you will now see a list of Customers and the CustomerID will not be a HyperLink. Press on a CustomerID and make sure it will navigate to the Customer View and display detail information about the selected Customer.

Note: The URL of the HyperLink’s href attribute does not point to a specific file, instead if will point to the Controller and the Action method to be executed when it’s pressed.

15. Add a new Action method to the CustomerController and name it “Remove”. Make sure it takes an ID of type string as an argument. Use LINQ to SQL to remove a Customer with the CustomerID matches the value of the ID argument. To Remove a Customer you first need to retrieve the Customer object, and then use the method DeleteOnSubmit method of the Customers property of the NorthwindDataContext object. The DeleteOnSubmit takes a Customer object as an argument. To execute the Delete, you need to call the SubmitChanges method of the NorthwindDataContext object.

Note: Both the View method and the Remove method will get a specific Customer by CustomerID, so you can do some refactoring here and use Extract method to extract code which will get the Customer by CustomerID and put it into a new method, and reuse that method both in the View and Remove Action method. To use the Refactoring feature within Visual Studio, mark the code you want to extract to a method and right click on the selected code block. Select Refactoring and Extract method option. Give the new method a name and press the OK button.

If you decide to use the Refactoring feature you can mark the following code in the View method:

Customer customer = (from c in northwindDataContext.Customers
                     where c.CustomerID == ID
                     select c).FirstOrDefault();

Righ click on the selected code and select Refactoring and Extract method. Give it the name “GetCustomerByID” and press the OK button. If you get an alert box, just press “Yes” to ignore it.

You should now have a new method with the name GetCustomerByID which the View method will make a call to.

In the Remove method, make a call to the GetCustomerByID to get the Customer object to delete. If the application fails to remove a Customer, throw an exception. If the remove was successfully, make a call to RedirectToAction to redirect to the Action with the name “List”. This will make sure the List method of the CustomerController will be called.


public ActionResult Remove(string ID)
{
    Customer customer = GetCustomerByID(ID);

    northwindDataContext.Customers.DeleteOnSubmit(customer);

    try
    {
        northwindDataContext.SubmitChanges();
        return RedirectToAction("List");
    }
    catch (Exception e)
    {
        throw new ApplicationException(string.Format("Can't remove the Customer {0}", ID), e);
    }
}

16. Next step is to add a HyperLink to the Customers View, and set the URL to “/Customer/Remove/<CustomerID>” for each Customer. The name of the HyperLink should be “Remove” and can be placed before the CustomerID HyperLink. When you press the HyperLink, the Remove method of the CustomerController will be called and it will remove the Customer.


<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customers.aspx.cs" Inherits="CustomerApp.Views.Customer.Customers" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <div>
        <table>
        <% foreach ( var customer in ViewData) { %>
            <tr>
                <td>
                <a href="/Customer/Remove/<%=customer.CustomerID %>">Remove</a>&nbsp;
                <a href="/Customer/View/<%=customer.CustomerID %>"><%=customer.CustomerID %></a>
                </td>
                <td><%=Html.Encode(customer.ContactName) %></td>
            </tr>
        <% } %>
        </table>
    </div>
</body>
</html>

Build the project and run the application, enter the URL to list Customers (By now you should know the URL). Press one of the Remove HyperLink. You will probably get a SQL Exception about reference problems. You aren’t going to resolve that exception. It will indicate that the remove was executed and in this lab you can be satisfied with that.

17. Add an Update method to the CustomerController, make sure it takes a argument with the name customerID and of type String. Use the customerID to call the GetCustomerByID method to retrieve the Customer from the database. Update the Customer with the new information and use the RedirectToAction method to redirect to the “List” action.

Note: When using LINQ to SQL we need to get a Customer which is attached to a DataContext, which is the reason why you need to get the Customer. Another reason is also to make it easy to handle concurrency issues etc.

Use the BindingHelperExtension class’s UpdateFrom method to set the Customer objects properties out from the Reuqest.Form collection.

Note: The BindingHelperExtension’s UpdateFrom method will get the value out from an input field with the same name as the property of the object passed to the UpdateFrom method and set the value to the object. In the Customer View, there were input fields with the same name as the properties of the Customer object, so those values will be “mapped” to the Customer object you will pass into the UpdateFrom method.

public ActionResult Update(string customerID)
{
    Customer customer = GetCustomerByID(customerID);

    BindingHelperExtensions.UpdateFrom(customer, Request.Form);

    try
    {
        northwindDataContext.SubmitChanges();
    }
    catch (Exception e)
    {
        throw new ApplicationException(
                string.Format("Can't update customer {0}", customerID)
                , e);
    }

    return RedirectToAction("List");
}

Note: Values of input fields on a View which has the same name as the arguments of the Update action method will be passed as a value to the respective argument. So in this case you have an input hidden field with the name CustomerID on the View, the value of that field, will be passed as a value to the Update method. So instead of using the UpdateFrom method of the BindingHelperExtensions, you could use arguments for all input fields.

If you want to learn more about the BindingHeperExtension class, you can read my post "ASP.Net MVC Framework 2 - The BindingHelperClass (UI-mapper)".

18. Open the Customer View and change the <form> element’s action argument to call the Update method of the CustomerController “/Customer/Update”. Add a Submit button to the View and give it the text value “Update”.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customer.aspx.cs" Inherits="CustomerApp.Views.Customer.Customer" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <form method="post" action="/Customer/Update">
        <table>
            <tr>
                <td>Customer ID:</td>
                <td><%= Html.Encode(ViewData.CustomerID) %></td>
            </tr>
            <tr>
                <td>Company name:</td>
                <td><input type="text" name="CompanyName" value="<%= Html.Encode(ViewData.CompanyName) %>" /></td>
            </tr>
            <tr>
                <td>Contact Name:</td>
                <td><input type="text" name="ContactName" value="<%= Html.Encode(ViewData.ContactName) %>" /></td>
            </tr>
            <tr>
                <td>Phone:</td>
                <td><input type="text" name="Phone" value="<%= Html.Encode(ViewData.Phone) %>" /></td>
            </tr>

        </table>

        <input type="hidden" name="CustomerID" value="<%= Html.Encode(ViewData.CustomerID) %>" />
        
        <input type="submit" value="Update" />
    </form>
</body>
</html>

Build the solution and run the application. Enter the URL to list all Customers “Customer/List” and select a Customer from the list. Update the Customer and press the Update button. When the Update button is pressed, the customer will be updated and you will be redirected to the List action so the List of Customer will be displayed.

Note: Instead of using an input field with the name CustomerID, you could also set the action attribute to “/Customer/Update/<the customerID>”.

The last thing to do now is to create an ActionFilter for the Remove action method. You only want to make sure the user with the name “student” will make a call to the Remove action method.

19. Add a new class to the Model folder. Name it “AuthorizedFilterAttribute”. Make sure it inherits from the base class ActionFilterAttribute. The ActionFilterAttribute is located in the namespace “System.Web.Mvc”.

The ActionFilter can be used to perform pre- and post action. You can use FilterAction to cancel an execution of an Action method, or you can use it to log information etc. The ActionFilter can now in pre-release of the Preview 3 of the ASP.Net MVC Framework also get access to the ActionResult returned from the Action method.

The ActionFilter AuthorizedFilter will be used to only make sure the user “student” has access to the Remove method, if not a SecurityException will be thrown.

To implement code for a pre action, override the OnActionExecuting method of the ActionFilterAttribute class. To perform a post action, override the OnActionExecuted method. To get the current user you can use the filterContext arugment’s HttpContext property and its User.Identity.name property. You don’t need to cancel the action of the AuthorizedFilter when you throw an exception. To cancel, you can set the filterContext Cancel property to true.


using System.Security;

namespace CustomerApp.Models
{
    public class AuthorizedFilter : ActionFilterAttribute
    {
        public override void OnActionExecuting(FilterExecutingContext filterContext)
        {
            if (filterContext.HttpContext.User.Identity.Name != "student")
                throw new SecurityException(
                      "You aren't allowed to call this action!");
        }
    }
}

Apply the AuthorizedFilter to the Remove method.

[AuthorizedFilter]
public void Remove(string ID)

Note: If you want to make sure the filter will be used for every Action method of a Controller, you can add the attribute to the Controller’s class.

If you want to test if the filter works, add a breakpoint to the OnActionExecuting method and run the application in debug mode. List the Customers and press the Remove HyperLink, or you can simply run the application, list the customers and press the Remove Hyperink, it should probably give you a SecurityException. If you want to learn more about ActionFilter, you can read my post "ASP.Net MVC Framework 2 - Interception and creating a Role Action Filter", I will later create a new post about the ActionFilter in the pre-release of Preview 3.

In this step by step guide you have learned how to create a simple application by using the ASP.Net MVC Framework pre-release of Preview 3. You have learned how to create a Controller, Views and also ActionFilter to intercept pre actions to a Action method.

ASP.Net MVC Framework Preview 2 - A step by step guide to create a simple Web Application

Fredrik N — Wed, 16 Apr 2008 08:50:00 GMT

UPDATE: When I cerated a new post on my blog about the pre-release of Preview 3, I replaced this one with the new post. I did my best to recover the content. Sorry!

In this post you will learn how to use most of the new features in the Preview 2 version of the ASP.NET Framework, you will also get a basic understanding about how to use LINQ to SQL. This step by step guide shouldn't be used as a "best way to create and design" a web applications by using the ASP.NET MVC Framework, this guide should only be used to get started with the MVC Framework in a fast and easy way and learn different ways to use some of the features shipped with the ASP.Net MVC Framework Preview 2.

To get the pre-release version, you can download it from here.

In this step by step guide you are going to create a web based application where you will be able to list and modify customers. This step by step guide will use C# 3.0 and the Northwind database.

1. Open Visual Studio 2008

2. Create a new Project and select the ”ASP.NET MVC Web Project” project and name it to “CustomerApp”.

3. Open global.asax and walk through the code. In Global.asax you can specify your routes. In this step by step guide you will use the default settings.

Note: The business objects belongs to the Model in the MVC pattern.

4. Right click on the Models folder in the Solution Explorer and select Add > New Item.

Select the “LINQ to SQL Classes” template and name the file to “Northwind.dbml” and press the Add button.

Server Name: (local)

Select the Northwind database, test the connection and press OK if you were able to connect to the database.

Now it’s time to create the Controller which you are going to use in this application.

5. Right click on the Controllers folder in the Solution Explorer and add a new item and select the “MVC Controller Class” template, name it to “CustomerController”.

6. Add a private field of the type NorhwindDataContext to the Controller and name the field to “northwindDataContext”. Set the field to an instance of the NorthwindDataContext object.

Note: The NorthwindDataContext class will exist in the CustomerApp.Models namespace.


using CustomerApp.Models;

namespace CustomerApp.Controllers
{
    public class CustomerController : Controller, IDisposable
    {
        private NorthwindDataContext northwindDataContext = new NorthwindDataContext();
       
        //...
    }
}


public class CustomerController : Controller, IDisposable
{
    private NorthwindDataContext northwindDataContext = new NorthwindDataContext();
   
    //...
    
    public void Dispose()
    {
        this.northwindDataContext.Dispose();
    }
}


public void List()
{
    List<Customer> customers = (from customer in northwindDataContext.Customers
                                orderby customer.CompanyName
                                select customer).ToList();

    RenderView("Customers", customers);
}


public partial class Customers : ViewPage<List<CustomerApp.Models.Customer>>
{
}


<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customers.aspx.cs" Inherits="CustomerApp.Views.Customer.Customers" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <div>
        <table>
        <% foreach ( var customer in ViewData) { %>
            <tr>
                <td><%=Html.Encode(customer.CustomerID) %></td>
                <td><%=Html.Encode(customer.ContactName) %></td>
            </tr>
        <% } %>
        </table>
    </div>
</body>
</html>

Note: The route that was defined in global.asax looks like this:

{controller}/{action}/{id}

11. Add a new Action method to the CustomerController and name it to “View”. The View method should have one argument with the name ID and the type of String. Make sure the method will use LINQ to SQL to get a Customer from the Customers table which matches the CustomerID passed as an argument. If a customer is not found throw an exception. Make sure to render a View with the name “Customer”. The View should ender a detail view of a Customer.

public void View(string ID)
{
    Customer customer = (from c in northwindDataContext.Customers
                         where c.CustomerID == ID
                         select c).FirstOrDefault();

    if (customer == null)
        throw new ApplicationException(
                    String.Format("Can't find a Customer with the CustomerID {0}", ID));

    RenderView("Customer", customer);
}

12. Add a new View to the Views/Customer folder and name it “Customer”. Make sure the Customer View will inherit form the ViewPage<CustomerApp.Models.Customer> class.


public partial class Customer : ViewPage<CustomerApp.Models.Customer>
{
}

Note: The Customer object has several properties, and to make this lab simple you can only use some of them, CustomerID, CompanyName, ContactName and Phone.

Leave the <Form> elements action attribute empty at the moment.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customer.aspx.cs" Inherits="CustomerApp.Views.Customer.Customer" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <form method="post" action="">
        <table>
            <tr>
                <td>Customer ID:</td>
                <td><%= Html.Encode(ViewData.CustomerID) %></td>
            </tr>
            <tr>
                <td>Company name:</td>
                <td><input type="text" name="CompanyName" value="<%= Html.Encode(ViewData.CompanyName) %>" /></td>
            </tr>
            <tr>
                <td>Contact Name:</td>
                <td><input type="text" name="ContactName" value="<%= Html.Encode(ViewData.ContactName) %>" /></td>
            </tr>
            <tr>
                <td>Phone:</td>
                <td><input type="text" name="Phone" value="<%= Html.Encode(ViewData.Phone) %>" /></td>
            </tr>

        </table>

        <input type="hidden" name="CustomerID" value="<%= Html.Encode(ViewData.CustomerID) %>" />
        
    </form>
</body>
</html>

Note: Instead of writing the whole <input> element, you can also use the Html help method:


<%= Html.TextBox("CompanyName", ViewData.CompanyName) %>

This method will render the following output:

<input type=”text” size=”20” name=”CompanyName” id=”CompanyName” value=”My Company”/>

Writing HTML will give you more control over the HTML which will be sent to the client.

If everything works, you will now see a detail view over the Customer with the CustomerID “ALFKI”.

14. Open the Customers.aspx View and make sure the listed CustomerID instead will be a HyperLink, which will have the following URL pattern: “/Customer/View/<CustomerID>”.


<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customers.aspx.cs" Inherits="CustomerApp.Views.Customer.Customers" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <div>
        <table>
        <% foreach ( var customer in ViewData) { %>
            <tr>
                <td>
                <a href="/Customer/View/<%=customer.CustomerID %>"><%=customer.CustomerID %></a>
                </td>
                <td><%=Html.Encode(customer.ContactName) %></td>
            </tr>
        <% } %>
        </table>
    </div>
</body>
</html>

Instead of writing the <a> element you can use the Html helper method to let it create an ActionLink, for example like this:


<%= Html.ActionLink<CustomerApp.Controllers.CustomerController>(a => a.View(customer.CustomerID), customer.CustomerID) %>

Note: The URL of the HyperLink’s href attribute does not point to a specific file, instead if will point to the Controller and the Action method to be executed when it’s pressed.

If you decide to use the Refactoring feature you can mark the following code in the View method:

Customer customer = (from c in northwindDataContext.Customers
                     where c.CustomerID == ID
                     select c).FirstOrDefault();

if (customer == null)
    throw new ApplicationException(
                String.Format("Can't find a Customer with the CustomerID {0}", ID));

Righ click on the selected code and select Refactoring and Extract method. Give it the name “GetCustomerByID” and press the OK button. If you get an alert box, just press “Yes” to ignore it.

You should now have a new method with the name GetCustomerByID which the View method will make a call to.

public void Remove(string ID)
{
    Customer customer = GetCustomerByID(ID);

    northwindDataContext.Customers.DeleteOnSubmit(customer);

    try
    {
        northwindDataContext.SubmitChanges();
        RedirectToAction("List");
    }
    catch (Exception e)
    {
        throw new ApplicationException(string.Format("Can't remove the Customer {0}", ID), e);
    }
}


<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customers.aspx.cs" Inherits="CustomerApp.Views.Customer.Customers" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <div>
        <table>
        <% foreach ( var customer in ViewData) { %>
            <tr>
                <td>
                <a href="/Customer/Remove/<%=customer.CustomerID %>">Remove</a>&nbsp;
                <a href="/Customer/View/<%=customer.CustomerID %>"><%=customer.CustomerID %></a>
                </td>
                <td><%=Html.Encode(customer.ContactName) %></td>
            </tr>
        <% } %>
        </table>
    </div>
</body>
</html>

Use the BindingHelperExtension class’s UpdateFrom method to set the Customer objects properties out from the Reuqest.Form collection.

public void Update(string customerID)
{
    Customer customer = GetCustomerByID(customerID);
    
    BindingHelperExtensions.UpdateFrom(customer, Request.Form);

    northwindDataContext.SubmitChanges();

    RedirectToAction("List");
}

If you want to learn more about the BindingHeperExtension class, you can read my post "ASP.Net MVC Framework 2 - The BindingHelperClass (UI-mapper)".

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customer.aspx.cs" Inherits="CustomerApp.Views.Customer.Customer" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <form method="post" action="/Customer/Update">
        <table>
            <tr>
                <td>Customer ID:</td>
                <td><%= Html.Encode(ViewData.CustomerID) %></td>
            </tr>
            <tr>
                <td>Company name:</td>
                <td><input type="text" name="CompanyName" value="<%= Html.Encode(ViewData.CompanyName) %>" /></td>
            </tr>
            <tr>
                <td>Contact Name:</td>
                <td><input type="text" name="ContactName" value="<%= Html.Encode(ViewData.ContactName) %>" /></td>
            </tr>
            <tr>
                <td>Phone:</td>
                <td><input type="text" name="Phone" value="<%= Html.Encode(ViewData.Phone) %>" /></td>
            </tr>

        </table>

        <input type="hidden" name="CustomerID" value="<%= Html.Encode(ViewData.CustomerID) %>" />
        
        <input type="submit" value="Update" />
    </form>
</body>
</html>

Note: Instead of using an input field with the name CustomerID, you could also set the action attribute to “/Customer/Update/<the customerID>”.

The last thing to do now is to create an ActionFilter for the Remove action method. You only want to make sure the user with the name “student” will make a call to the Remove action method.

The ActionFilter can be used to perform pre- and post action. You can use FilterAction to cancel an execution of an Action method, or you can use it to log information etc.

The ActionFilter AuthorizedFilter will be used to only make sure the user “student” has access to the Remove method, if not a SecurityException will be thrown.


using System.Security;

namespace CustomerApp.Models
{
    public class AuthorizedFilter : ActionFilterAttribute
    {
        public override void OnActionExecuting(FilterExecutingContext filterContext)
        {
            if (filterContext.HttpContext.User.Identity.Name != "student")
                throw new SecurityException(
                      "You aren't allowed to call this action!");
        }
    }
}

Apply the AuthorizedFilter to the Remove method.

[AuthorizedFilter]
public void Remove(string ID)

Note: If you want to make sure the filter will be used for every Action method of a Controller, you can add the attribute to the Controller’s class.

In this step by step guide you have learned how to create a simple application by using the ASP.Net MVC Framework Preview 2. You have learned how to create a Controller, Views and also ActionFilter to intercept pre actions to a Action method.

ASP.Net MVC Framework 2 - The Binding helper class (UI-mapper)

Fredrik N — Thu, 13 Mar 2008 13:57:00 GMT

In this post I’m going to explain the use of the ASP.Net MVC Framework’s BindingHelperExtensions class and how to use it as what I call a UI mapper (map user input fields to an object). The BindingHelperExtensions has the following five methods:

T ReadFromRequest<T>(this Controller controller, String key)

string ReadFromRequest(this Controller controller, String key)

void UpdateFrom(Object value, NameValueCollection values)

void UpdateFrom(Object value, NameValueCollection values, string objectPrefix)

void UpdateFrom(Object value, NameValueCollection values, string[] keys)

I will not go deep into the ReadFromRequest method, but they can be used to get a value out from the Request object, such as a QueryString or Form field. They are also extensions method to the Controller class. In this post I will write about the UpdateFrom methods which can be used to easy map a View’s user input fields to an object.

Note: The UpdateFrom methods aren’t extension methods.

The UpdateFrom methods can be used inside of a Controller’s action method to update an object in the Model based on input values. For example if you have a Customer object and want to fill it with values out from the Request.From, you can do the following in your Controller:

Binding.UpdateFrom(customer, Request.Form);

In the examples in this post I will use an alias:

using Binding = System.Web.Mvc.BindingHelperExtensions;

I only use it to avoid using the name of the BindingHelperExtension class to get access to the UpdateFrom methods.

The UpdateFrom will see if there is an input field in the Request.Form collection with the same name as the property of the object passed as an argument. If there is a match, the value from input filed will be set to the value of the object’s property with the same name. For example if you have an input filed like this:

<input type="text" name="CompanyName" .../>

And if the Customer object you pass to the UpdateFrom method has a property with the same name; the value from the CompanyName field will be set to the Customer’s CompanyName property. If you have a View like this:

<input type="text" name="CompanyName" />

<input type="submit" name="City" value="Create"/>

The value of the submit button will be set to the Customer object if it has a property with the name City. So be careful what name you set to the input elements. This can of course be handled by using one of the other two UpdateFrom methods. For example the UpdateFrom that takes a objectPrefix as an argument, can be used to pass in a prefix of the input field names which should be collected from the values argument and be set to the value argument.

void UpdateFrom(Object value, NameValueCollection values, string objectPrefix)

For example if you have input fields that you want to belong to a specific object in the Model, you can use an object prefix like this:

<input type="text" name="Customer.CompanyName" />
<input type="text" name="Customer.ContactName" />
<input type="text" name="Product.Description" />

Note: You can also use "_" to sepereate the prefix from the property name "Customer_CompanyName".

When you use the UdateFrom method and you only want to map the values from the input fields with the prefix Customer to a Customer object passed to the UpdateFrom, you simply pass the “Customer” as an objectPrefix to the UpdateFrom method:

Binding.UpdateFrom(customer, Request.Form, "Customer");

The UpdateFrom will now only collect fields with the prefix “Customer”, and the names after the prefix will be mapped to properties of the Customer object with the same name. By using object prefix you can simply categorize input fields to be mapped to different objects. The last UpdateFrom method you can use is the one that takes an array of keys as an argument.

void UpdateFrom(Object value, NameValueCollection values, string[] keys)

By passing a string array with keys, only the specified keys will be collected from the values argument collection and be set to the value object’s properties. By using keys and pass a Request.Form to the values argument you can decide which input fields you want to collect.

Note: The values argument of the UpdateFrom takes an object of type NameValueCollection, so you pass for example pass the Request.Params collection if you want to get values from both QueryStrings and Forms. You can also pass your own NameValueCollection as you probably already have figured out ;)

To end this post I will give you a simple example how to use the UpdateFrom and with LINQ to SQL to create a new Customer to the Northwind database.

public class CustomerController : Controller
{
    private NorthwindDataContext dbc = new NorthwindDataContext();

    public void Index()
    {
       RenderView("Customer");
    }

    public void New()
    {
      Customer customer = new Customer();

      Binding.UpdateFrom(customer, Request.Form, "Customer");

      dbc.Customers.InsertOnSubmit(customer);
      dbc.SubmitChanges();
    }
}

Customer.aspx

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Customer.aspx.cs" Inherits="MvcUpdateInsertExample.Views.Customer.Customer" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <div>
        <form action="Customer/New" method="post">
        
        Company name: <input type="text" name="Customer.CompanyName" /><br />
        Contact name: <input type="text" name="Customer.ContactName" /><br />
        
        <input type="submit" value="Create"/>
        
        </form>
    </div>
</body>
</html>

I hope this post gave you some brief understanding about how you can use the BindingHelperExtensions class to easy handle user input and map it to an object in the Model.

ASP.Net MVC Framework 2 - Interception and creating a Role Action Filter

Fredrik N — Wed, 12 Mar 2008 08:50:00 GMT

With the ASP.Net MVC Framework Preview 2, we can use Action Filters. An Action Filter can be used to intercept actions before and after an Action method of a Controller is executed. By using Action Filters you can for example add code that will check if a user has the right permission to access a action method, or you can use it to log messaged before and action is executed, and also after. An Action Filter is easy to apply to a Controller or its Action method. Just add the ActionFilter as an attribute to the class or specific method of a Controller.

[RoleFilter(AllowRoles="Admin,Everyone"]
public class MyController
{
    [MyFilter]
    public void Index()
    {
        …
        RenderView("Index");
    }
}

If you apply an Aciton Filter to the Controller class, it will be executed for every action method in the Controller, if you add Action Filter to a specific method, it will only be called when that specific method is executed. An Action Filter has two methods that you can override and use, OnActionExecuting and OnActionExecuted. As you probably can get out from the names, the Executing method will be called before the action method is executed, and the Executed, after the action method is executed. I will write more about the both method later in this post. You can apply several Action Filters to a Controller. One thing you need to have in mind is the order they will be executed. Reflection is used to get the Action Filters out from a Controller, Reflection can’t promise to give items in the order which they are applied. To solve this we can use the Order property of an Action Filter. By using the Order property we can specify in which order the Action Filter should be executed.

[MyFilter(Order=1)]
[MyFilter2(Order=2)]
[MyFilter3(Order=3)]
public void Index()

The OnActionExecuting method, which is the method that will be executed before an Action method of a Controller is executed, has one argument, filterContext of type FilterExecutingContext. The FilterExecutingContext has the following properties:

ActionMethod
Cancel
Controller
HttpContext
RouteData

The ActionMethod is of type MemberInfo and can give you all the information needed of the Action method that are going to be executed. The Cancel property is a Boolean where you can set it to true to cancel all execution of Action Filters and avoid calling the Action method. The Controller property is of type IController and will give you access to the current Controller. The HttpContext is of type HttpContextBase and will give you access to the HttpContext. The RouteData will give you access to the current route information. The OnActionExecuted method takes an argument of type FilterExecutedContext, which have the same properties as the FilterExecutingContex except Cancel and have two other properties, Exception which can be used to get an Exception thrown inside of an Action method, ExceptionHandled can be used to specify if you have handled the exception or not. The reason why the FilterExecutedContext don’t have the Cancel property is because you can’t cancel an action method that has already been executed. If you want a common way to handle exceptions thrown from an Action method, you can use the OnActionExecuted method to log or handle the exception in your own way, instead of showing the ASP.Net yellow error page.

The Controller base class has two methods which can also be used to handle pre and post action for every action methods of the Controller. They have the same name and interface as the Action Filter’s OnActionExecuting and OnActionExecuted methods.

public class MyController : Controller
{
    public override void OnActionExecuting(FilterExecutingContext filterContext)
    {
    }

    public override void OnActionExecuted(FilterExecutedContext filterContext)
    {
    }
}

If you need to use some unique logic for a specific Controller on every action that is called, you can override the OnActionExecuting and Executed methods of the Controller, if not, it’s better to use an Action Filter, so you can reuse code among the Controllers.
The execution of an Action method is the following when an Action filter is used:

Controller.OnActionExecuting

ActionFilter.OnActionExecuting

Controller’s Action method Executed

ActionFilter.OnActionExecuted

Controller.OnActionExecuted

To implement an Action Filter you need to create a class which inherits from the ActionFilterAttribute, where you override the ActionFilterAttribute’s OnActionExectuing or Executed methods or both if you want to use both pre and post actions:

public class MyFilterAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(FilterExecutingContext filterContext)
    {
    }

    public override void OnActionExecuted(FilterExecutedContext filterContext)
    {
    }
}

When the Action Filter is created you can simply apply the attribute to a Controller’s Class definition (if you want the pre and post action to be executed for every action method) or to methods (if you only want to make sure the pre and post action should be used on a particular method).
The following Action Filter can be used to make sure that only a user to a specified role can execute the action method. In this code the Roles feature of ASP.Net is used:

using System;
using System.Web.Mvc;
using System.Web.Security;
using System.Security;

public class RoleFilterAttribute : ActionFilterAttribute
{
    public string Roles { get; set; }


    public override void OnActionExecuting(FilterExecutingContext filterContext)
    {
        string[] userRoles = System.Web.Security.Roles.GetRolesForUser();

        foreach (string definedRole in this.Roles.Split(','))
        {
            foreach (string role in userRoles)
            {
                if (definedRole.Equals(role))
                    return;
            }
        }

        throw new SecurityException("Access not granted!");
    }

}

When the attribute is created, you can simply add it to the Controller.

[RoleFilter(Roles="Admin")]
public void ListUser()
{
    //...
    RenderView("Users");
}

The only thing I want now for make it easier to add or remove interceptors, is to make it possible to set them up in a configuration file. In that way we can add or remove interceptors from a Controller without recompile our application. We can use Spring.Net’s Aspect Oriented Programming (AOP) support to add interceptors, but it would be so nice to have AOP support added to C# ;)

ASP.Net MVC Framework 2 - Define Routes in Web.config

Fredrik N — Tue, 11 Mar 2008 15:06:00 GMT

Something I like with ASP.Net MVC Framework Preview 2 is the RouteValueDictionary used by the Route class’s Defaults, Constraints and DataTokens property, before they use an anonymous type. Because the properties are now a specific type it’s much easier to define the routes in web.config. Before it was quite easy but some reflection was needed. I have now created a ConfigSection and a helper method to easily register routes which can be defined in the web.config for the Preview 2 version of the ASP.Net MVC Framework. I decided to use the following XML structure to define routes in web.config:

<routeTable>
  <routes>
  
   <add 
      name="Microsoft" 
      url="{controller}/{action}/{id}" 
      routeHandlerType="MyMvcRouteHandler">
      
      <defaults action="Index" id=""/>
      <constraints id="..."/>
      <dataTokens/>
    
   </add>
    
    <add name="Default" url="Default.aspx">
      <defaults controller="Home" action="Index" id=""/>
    </add>
  
  </routes>
</routeTable>

In my solution I also decided to make sure the “name” attribute of a route <add> is required and used as a key. The two other attributes of the route <add> are “url” and “routeHandlerType”, used to specify the Url and the type of a IRouteHandler to use (by default if it's empty the MvcRouteHandler will be used). I decided to use three child elements to the <add> element, <defaults>, <constraints> and <dataTokens>. Each attribute added to those elements will be added to the property of the Route class with the same name as the element and as a key, value dictionary of type RouteValueDictionary. To make it easy to register and read the routeTable out from the web.config, I created a helper class “RouteTableManager”. By calling its static method “RegisterRoute” from Application_Start in global.asax, the routes were registered.

RouteTableManager.RegisterRoutes(RouteTable.Routes);

RouteTableManager.RegisterRoutes();

The last method will use the RouteTable class internally.

By creating a custom MvcRouteModule and override the Init method, the routes can be automatically registered without using global.asax.

public class MyUrlRouteingModule : UrlRoutingModule
{
    protected override void Init(HttpApplication application)
    {
        RouteTableManager.RegisterRoutes();
        base.Init(application);
    }
}

You can download the whole source code from here..

Note: The code will only read the routes from the Configuration file, you can’t use it to modify or add new routes. The idea is only to define the routes in a config file instead of adding them manually in the global.asax’s Application_Start event. I also put the source code into the Model directory of the ASP.Net MVC Project, it should be separated into an own assembly, but I was lazy ;)

ASP.Net MVC Framework - Using Forms Authentication

Fredrik N — Thu, 07 Feb 2008 08:59:00 GMT

NOTE: THIS Post was written when ASP.NET MVC Framework was in a early Preview stage.

This post is about using Forms Authentication with the MVC Framework. I only want to let you know that this is a simple and fast “hack” only to show a simple solution to get it work. I decided to use the Membership feature for the validation of user name and password.

The first thing we need to do is to enable Forms Authentication and specify a Login Url, I decided to use the Login URL in a MVC “friendly” format:

The value of the loginUrl has some redundant value, Login/Login, but this is because the first Login points to the LoginController and the last Login to the Action method Login in the LoginController.

The next thing we need to do is to make sure anonymous users don’t have access to our site, this is done by adding the authorization section to the web.config:

If a user now try to get access to our site, he/she will be redirected to the ”Login/Login” URL, this will happen if we use the following URL format in the RouteTable:

Url = "[controller]/[action]"

A call to the Login Action method of the LoginController will take place.

In the Views folder we can add our Login View (We will look at the LoginController later in this post).

/Views/Login/Login.aspx

The following is a simple Login View:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Login.aspx.cs" Inherits="MvcApplication4.Views.Login.Login" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head runat="server">
<title>Untitled Page</title>
</head>

        <form method="post" action="/Login/Login">
        User name: <input type="text" name="userName" /><br />
        Password:  <input type="password" name="password" /><br /><br />
        <input type="submit" value="Login" />
        </form>

</div>

</body>
</html>

If the ViewData in will contain an data item with the name LoginFaild it will display the value added to the LingFaild data item, in this case a message like “Login faild….”

The <form> element’s action method will make sure the LoginController’s Login method will be called when the user hit the Login submit button. As you can see the same URL specified for the FormsAuthentication’s loginUrl is used here. It’s because the <location> section in the web.config will not work properly with the MVC Framework "friendly" URL, so if we try to use another URL like “/Login/Authenticate” etc, we will be redirected to the “Login/Login” URL because the <authorization> section denies all anonymous user to access any URL in our app, besides the specified loginUrl.

Note: The <location> will still work for CSS files etc. So to enable a css style when we deny anonymouse use to access "files" in our web site, we can add the <location> to make sure CSS files and images etc can be requested.

The username and password input fields values will be passed as arguments to the Login action of the LoginController. Here is the implementation of the LoginController and its Login action:

    public class LoginController : Controller
    {
        [ControllerAction]
        public void Login(string userName, string password, string ReturnUrl)
        {
            if (this.IsValidLoginArgument(userName, password))
            {
                if (Membership.ValidateUser(userName, password))
                    this.RedirectFromLoginPage(userName, ReturnUrl);
                else
                    this.ViewData["LoginFaild"] = "Login faild! Make sure you have entered the right user name and password!";
            }

RenderView("Login");
}

        private void RedirectFromLoginPage(string userName, string ReturnUrl)
        {
            FormsAuthentication.SetAuthCookie(userName, false);

            if (!string.IsNullOrEmpty(ReturnUrl))
                Response.Redirect(ReturnUrl);
            else
                Response.Redirect(FormsAuthentication.DefaultUrl);
        }

        private bool IsValidLoginArgument(string userName, string password)
        {
            return !(string.IsNullOrEmpty(userName) && string.IsNullOrEmpty(password));
        }
    }

As you can see the Login action method takes three arguments, the userName, password and ReturnUrl. The value for the userName and password, will came from the input fields located on the Login View, the ReturnUrl is a query string used by the FormsAuthentication, so the value of the ReutnrUrl argument will came from the ReturnUrl query string. If we have input fields with the same name as the arguments of an action method in the View, the value of the fields will be “mapped” to the argument of the action method with the same name as the field, the same thing with query strings.

Note: There is a bug in the current CTP of the MVC Framework, so the value of a query string will not always be passed to the action method’s arguments.

The firs lines of code in the Login action method will check if the username and password aren’t empty. The check is used to make sure the Login View will be displayed when FormsAuthentication will redirect to the LoginURL “Login/Login”. If a user tries to enter and URL and the user is an anonymous user (Not authenticated), the Login Action method of the LoginController will be executed. In this case the username and password argument will be null, and the Login View will be rendered. When the Login view is displayed, the user can now enter a username and a password and hit the Login button. When he/she have done that, the LoginController’s Action method will be called, and this time the username and password will not be empty, so the Membership feature will validate the user, if he/she is valid, the Authentication Cookie used by the FormsAutehtnicon will be set, and the user will be redirected to the URL he/she have requested, and the user is now authenticated and have access to the site.

If the user enter a invalid user name or password, the Login View will be displayed and the “Login faild!.....” text added to the ViewData will be displayed.

This was a simple solution to use the Forms Authentication, there are some other options where can simply create our own RouteHandler which can handle the authentication check and redirect to a login View, or we can handle it on a Controller level. I will probably write a blog post about that later.

I have another post about the MVC Framework and security: http://weblogs.asp.net/fredriknormen/archive/2007/11/25/asp-net-mvc-framework-security.aspx. The post is created on the pre-CTP of the MVC Framework, so have that in mind, but basically the solution is the same.

ASP.Net MVC Framework - Assign a ViewFactory to a Controller

Fredrik N — Wed, 30 Jan 2008 06:21:00 GMT

I have seen several posts about how to assign a ViewFactory to a Controller, most of the case the code looks like this:

public class HomeController : Controller
{
    public HomeController()
    {
       this.ViewFactory = new MyViewFactory();
    }
}

The ViewFactory is assigned into the constructor of a Controller. If we want to use the same ViewFactroy for all Controllers in out app, we can for example create a new base class for our Controller:

public class MyController : Controller
{
     public MyContoroller()
     {
         this.ViewFactory = new MyViewFactory();
     }
}

public class HomeController : MyController
{
     public HomeController() : base()
     {
     }
}

I’m a more fan of making this configurable via a configuration file, to map a ViewFacotry to a Controller, this can for example be done with Spring.Net:

<?xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net"
                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xsi:schemaLocation="http://www.springframework.net http://www.springframework.net/xsd/spring-objects.xsd">

<object id="HomeController" type="MvcApplication.Controllers.HomeController, MvcApplication, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null">
    <constructor-arg name="viewFactory" ref="MyFactory"/>
</object>

<object id="MyFactory" type="MyViewFactory, MvcApplication, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>

</objects>

Note: You can read my other post about using Spring.Net to create Controllers.

public class HomeController : Controller
{
   public HomeController() : this(new DefaultViewFactory ()) {}
   public HomeController(IViewFactory viewFactory)
   {
       this.ViewFactory = viewFactory;
   }
}

There a so many different solutions to set a ViewFactory during creation of a Controller, for example by creating an own ControllerFactory, the following code is from my post about writing your own IRoutHandler:

public IController CreateController(RequestContext context, string controllerName)
{
        //I should refactor out the following two lines to not only make sure to make the creation of the ObjectFactory once.
        IResource input = new FileSystemResource(context.HttpContext.Request.MapPath("objects.xml"));
        IObjectFactory factory = new XmlObjectFactory(input);

        IController controller = (IController)factory.GetObject(controllerName, typeof(IController));

        if (typeof(Controller).IsAssignableFrom(controller.GetType()))
        {
          N2MVCConfigurationHandler config = ConfigurationManager.GetSection("Nsquared2/N2MVCSection") as N2MVCConfigurationHandler;
          ((Controller)controller).ViewFactory = N2ViewFactoryBuilder.GetViewFactory(config.ViewFactory);
        }

return controller;
}

What this code does, is to see if the Controller is assigned from the Controller class, ugly code, I know, but it’s only the Controller base class that has the ViewFactory property, and we can create a Controller which only implements the IController interface, and this interface don’t have the ViewFactory property.

The code above will get the ViewFactory from a configuration file:

In this example I assume that every Controller use the same ViewFactory, and that may not always be the case, so in that case the earlier example by using Spring.Net an inject a ViewFactory would be better use, or creating a new ControllerFactory which will map a Controller to a ViewFactory, so when the ControllerFactory creates the Controller, the factory could look up in a config file to see, which ViewFactory should be used for the specific Controller, for example:

What is the main goal with these kinds of solutions? Well we can now simply change the ViewFactory for our Controller without recompiling our code, and we will also remove the dependency from a Controller and the ViewFactory by not hard code the instantiation within the Controllers. I prefer Interface Driven Programming and the use of factories, and the possibility to easy configure the use of classes etc in a configuration file. That is why I also loved the Provider based solution that was shipped with ASP.Net 2.0, like the Membership and Roles features etc.

MVC - Expression Language and custom tags

Fredrik N — Tue, 27 Nov 2007 10:52:00 GMT

I have seen several developers that want and have no problem by using server-side code blocks in a View when they are working with the MVC pattern. But I think the server-side code block should be used only in some advanced and special occasions and instead use an Expression Language. By using a lot of server-side code block can make the View messy and the solution can be difficult to implement, form the perspective of code maintainability and extensibility. If we instead use tags similar to HTML/XML we can make the code blend into HTML in a nice way.

Take a look at the following code:

<% if (ViewData != null && ViewData.HasError) {%>
...
<% } %>

<% if (ViewData.ExceptionType == ExceptionType.Critical) %>
      <div class="criticalException">
          Critical Error: <%= ViewData.ExceptionMessage%>
          <% if (ViewData.InnerException != null) } %>
             <%=ViewData.InnerException.Message%>
          <% } %>
     </div>
<% else %>
     <div class="exception">
        Error message :<br/><%= ViewData.ExceptionMessage%>
     </div>
<% } %>

The above code is only used to demonstrate how messy a View can be when we have a lot of server-side code blocks. This code will not be easy for a designer or web developer to maintain. If we instead use an Expression Language (EL) and JSTL (JSP Stamdard Tag Library) for JSP in ASP.Net the View can be written like this:

<c:if test="${ViewData!=null && ViewData.HasError}">
...
</c:if>

<c:choose>
     <c:when test="${ExceptionType == ExceptionType.Critical}">
         <div class="criticalException">
            Critical Error: <c:out value="${ViewData.ExceptionMessage}"/>
            <c:out value="${ViewData.InnerException.Message}"/>
         </div>
      <c:otherwice>
         <div class="exception">
            Error message :<br/><c:out value="${ViewData.ExceptionMessage}"/>
         </div>
       </c:otherwice>
</c:choose>

The best part of the ${variable} is that it can evaluate null for us, and also do the type casting, so we don’t need to write:

<% if (ViewData.InnerException != null) } %>
<%=ViewData.InnerException.Message%>
<% } %>

or:

<%=ViewData.CustomerID.ToString()%>

Instead we simply write:

${ViewData.InnerException.Message}

${ViewData.CustomerID}

The best part, we shouldn't event need to use the ViewData, instead directly write:

${CustomerID}

Here is an example where a property path (sub-properties) is used:

${Order.Rows[1].Item.Price}

In some cases we need some more logic to test some conditions etc, something that can’t be placed inside of a Controller. This logic can instead of being a server-code block be capsulated into an own custom tag.

The problem with EL today is the lack of supports in tools, so we only get an error first at runt-time and some IDE don’t have support for easy handle the EL. To make it more powerful the tools need to handle it also. But I prefer this way instead of using server-side code block and I hope something similar will be added to the ASP.NET MVC Framework.

Nikhil wrote a post about using AJAX with the ASP.Net MVC Framework (only a prototype). He uses code like this:

<% RenderBeginAjaxForm(Url.Action("Add"),
                       new { Update="taskList, UpdateType="appendBottom",
                             Highlight="True",
                             Starting="startAddTask", Completed="endAddTask" }); %>
   <input type="text" name="name" id="nameTextBox" />
   <% Ajax.Watermark("nameTextBox",
                  new { watermarkText="[What do you need to do?]", watermarkCssClass="watermark"}); %>

   <input type="submit" name="addTask" value="Add Task" />
<% RenderEndForm(); %>

The RenderBeginAjaxForm will render a <form> element with an onClick and onSubmit attribute etc. The RenderEndForm will also add a </form> The Ajax.Watermark is a way to extend a HTML element with a WaterMarker. I think this code is kind of “messy”. I would like to see some tags instead for example:

<ajax:Form Action="Add" Update="takstList" UpdateType="appendBottom" Hightlight="true" ...>
<ajax:waterMarkTextBox name="name" id="nameTextBox" markerText="[What do you need to do?]".../>
</ajax:form>

By using this solution, tags will be nicely blended into HTML and remove server-side code and make it easy for web developers (They are used to HTML element and attribute) to simple apply it and also maintain it. We can also easy see that we have a <form> and a </form>. This looks similar to Server controls today but this should be a more light-weight control, and the runat=”server” shouldn’t be used ;) This is similar to ViewComponent shipped with MonoRail (I think ;)), but I don’t like the declaration syntax MonoRail used. I prefer to use a HTML similar way to add components (custom tags) etc.

What kind of solution do you prefer?

ASP.NET MVC Framework - Ajax

Fredrik N — Mon, 26 Nov 2007 16:00:00 GMT

Take look at Nikhil's blog about how AJAX can be used with the ASP.Net MVC Framework:

http://www.nikhilk.net/Ajax-MVC.aspx

ASP.Net MVC Framework - Security

Fredrik N — Sun, 25 Nov 2007 11:37:00 GMT

Note: This post is based on an early version of the ASP.Net MVC Framework, not the final version, so changes my happen in the future.

When using the ASP.Net MVC Framework it will do a URL routing to route an URL to a Controller, and the Controller should execute some logic and render the Views. We can for example use an URL like /Products/Edit/1 to edit a product. By using this kind of URL we need to care about security, because we don’t want everyone to be able to edit a product. How can we prevent some users to not edit the product? We can’t use the <location> element and deny certain user for accessing the View.

<location path="Views/Products/Edit.aspx">
   <system.web>
     <authorization>
       <deny users="*"/>
     </authorization>
   </system.web>
</location>

The above section will not work, well sort of; it will make sure no one can access the Edit.aspx page. But if we use the RenderView method to render a View the <location> element will not work, the View will still be rendered. So what other options do we have? When we use the MVC framework the Controllers are responsible to handle the logic and the render of Views. We can in this case add the security check into our Controllers, in this case into the Action methods. As you may know a Controller can have several actions, like Edit, Update and List etc and they can also render different Views. Maybe the List action should everyone be possible to call, but not the Edit or Update methods. So in this case we need to add the security check on the Edit and Update methods in a Controller. This can for example be done by using the Roles feature of ASP.Net:

[ControllerAction]
public void Edit(int? id)
{
if (!Roles.IsUserInRole("Admin"))
throw new SecurityException("Access denied");
...
}

To avoid writing this check in the Action methods we can instead use the PrincipalPermissionAttributes shipped with .Net:

[ControllerAction]
[PrincipalPermission(SecurityAction.Demand, Role="Admin"]
public void Edit(int? id)
{
...
}

If we want to make sure all Action methods in a Controller have the check, we can add the PrincipalPermissionAttribute to the Controller class:

[PrincipalPermission(SecurityAction.Demand, Role="Admin")]
public class HomeController : Controller

If we want to handle the SecurityException we can use the ExceptionHandlerAttribute I wrote about in my previous post. This can catch the SecurityException and Render a View that will display the exception message.

[ControllerAction]
[PrincipalPermission(SecurityAction.Demand, Role="Admin"]
[ExceptionHandler("Error", typeof(SecurityException))]
public void Edit(int? id)
{
...
}

If we don’t want to use the PrincipalPermissionAttribute and instead write our own Security handler, we can override the OnPreAction method and implement the security check. The OnPreAction method will be executed before any Action methods are executed.

protected override void OnPreAction(string actionName, System.Reflection.MethodInfo methodInfo)
{
   if (actionName == "Edit")
   {
     if (!Roles.IsUserInRole("Admin") || !User.Identity.IsAuthenticated || !User.Identity.Name = "Administrator")
        throw SecurityException("Access denied!");
   }
}

ASP.Net MVC Framework - Handling Exception by using an Attribute

Fredrik N — Wed, 21 Nov 2007 23:04:00 GMT

Note: This is based on the pre-CTP version of the ASP.Net MVC Framework and it is in an early stage.

I got a comment on one my previous post “ASP.Net MVC Framework - Exception Handling” that the Rescue style MonoRail is a nice solution to handle Exception thrown within a Controller. In this post I have added something similar to as the Rescue feature of MonoRail (at least I think so ;)) where an attribute can be added to a Controller or on an Action. The attribute can be used to specify which View that should be rendered when an exception is thrown. We can also specify different Views based on different exceptions. Something I also added to the code is to specify something I will call an ExceptionHanlder. The ExceptionHandler is a pre handler which will be executed before the specified exception View should be rendered. The idea of the ExceptionHandler is to log exception etc.

By using an Attribute (ExceptionHandlerAttribute) on a Controller or an Action method, we don’t need to override the OnError method of the base Controller class. I made this solution simple by only creating my own custom Controller class (N2Controller) and override the OnError method of the Controller. In this method do my exception handling process. Before I show the code I will show you how we can use the ExceptionHandlerAttribute.

The ExceptionHandlerAttribute has three argument, exceptionHandler, viewName, exceptionType. The exceptionHandler argument is where we pass the type of the pre ExceptionHandler we want to use when an Exception is thrown. The viewName is the name of the View to render the exception information (In this sample code the view specified must be located in the Views/Exceptions folder). The exceptionType takes a type of an Exception. If we only want to make sure the Exception Handler should only handle a specific exception thrown within the Controller or Action method, we use the exceptionType argument.

Here is an example of different use of the ExcetpionHandlerAttribute, it can be used on both the Controller’s Class and Action methods:

1. [ExceptionHandler(“Error”);
2. [ExceptionHandler("Error", typeof(DivideByZeroException))]
3. [ExceptionHandler(typeof(ExceptionHandler), "Error")]
4. [ExceptionHandler(typeof(ExceptionHandler), "Error", typeof(DividedByZeroException))
5. [ExceptionHandler(typeof(ExceptionHandler))
6. [ExceptionHandler(typeof(ExceptionHandler), typeof(DividedByZeroException))

1 Will who the Error view when an exception is thrown.
2 Will only show the Error View is the exception thrown is of type DividedByZeroException.
3 Will Show the Error View and use a pre ExceptionHandler before the View is rendered.
4 Will Show the Error View only if the DividedByZeroException is thrown, and use a pre ExceptionHandler before the View is rendered.
5 Will use the ExceptionHandler when an exception is thrown.
6 Will use the ExceptionHandler if the DividedByZeroException is thrown.

To use ExceptionHandler we simply create a Class that implements the IExceptionHandler interface.

public interface IExceptionHandler
{
void PreExceptionHandling(string actionName, Exception exception);
}

In the PreExceptionHandling method we could for example put logic to log an exception. The PreExceptionHandling method will be called before a View will be rendered (A View will not be rendered if it’s not specified).

Here is an example how the ExceptionHandlerAttribute can be used:

[ExceptionHandler("DefaultError", typeof(DivideByZeroException))]   <- Will not be used
public class HomeController : N2Controller
{
   [ControllerAction, ExceptionHandler("Error")] <- Will be used
   public void Index()
   {

   }
}

The attribute specified on the action method will have more to sat than the attribute on the Controller’s class.

[ExceptionHandler("DefaultError", typeof(DivideByZeroException))]   <- Will be used
public class HomeController : N2Controller
{
    [ControllerAction, ExceptionHandler("Error",typeof(IndexOutOfRangeException),typeof(ArgumentException))] <- Will be used
    public void Index()
    {
        ...
    }
}

In the code above, both Exception Handler will be used. For example, if the Action method throws a DidivedByZeroException the DefaultError View will be rendered. But if the IndexOurOfRangeException or ArgumetnException is thrown the Error View will be displayed.

Here is the implementation of my custom Controller:

public class N2Controller : Controller
{
    protected override bool OnError(string actionName, System.Reflection.MethodInfo methodInfo, Exception exception)
    {
        ArrayList attributes = this.GetExceptionHandlerAttribute(methodInfo);

        foreach (ExceptionHandlerAttribute attribute in attributes)
        {
           foreach (Type exceptionType in attribute.ExceptionTypes)
           {
              if (exceptionType.IsAssignableFrom(exception.InnerException.GetType()))
            {
               if (attribute.ExceptionHandler != null)
                    ((IExceptionHandler)Activator.CreateInstance(attribute.ExceptionHandler)).PreExceptionHandling(actionName, exception);

                 if (!string.IsNullOrEmpty(attribute.View))
                     RenderView("~/Views/Exceptions/" + attribute.View + ".aspx", exception);

                 return false;
              }
           }
       }

return true;
}

   private ArrayList GetExceptionHandlerAttribute(System.Reflection.MethodInfo methodInfo)
   {
       ArrayList attributes = new ArrayList();

       attributes.AddRange(
                           methodInfo.GetCustomAttributes(
                                 typeof(ExceptionHandlerAttribute),
                                 false));

       attributes.AddRange(
                           this.GetType().GetCustomAttributes(
                           typeof(ExceptionHandlerAttribute),
                           true));

       return attributes;
    }
}

The code above is only on a prototype stage and. If no ExceptionHandlerAttribute is specified for an Action or Controller, the original ASP.Net MVC Frameowork’s OnError behavior will be used.

ASP.Net MVC Framework - Exception Handling

Fredrik N — Mon, 19 Nov 2007 21:42:00 GMT

Note: This post is based on an early preview version of the ASP.Net MVC Framework and much will happen until the next milestone.

In this post I will show how we can handle errors that occur in a Controller’s Action method.
The Controller base class has a virtual method with the name OnError, this method takes three arguments, actionName, methodInfo and exception. It also has a return type of a Boolean. The idea when using the OnError method is to return true if we have handled the exception or false to letting ASP.Net handle it for us.

protected virtual bool OnError(string actionName, System.Reflection.MethodInfo methodInfo, Exception exception)

When an exception is thrown within our Action method, the OnError method will be executed. In the OnError method we can for example pass information to a View.

Here is an example of a Controller where I will Render a View called “Error” and pass the exception to the View:

public class HomeController : Controller
{
    protected override bool OnError(string actionName, System.Reflection.MethodInfo methodInfo, Exception exception)
    {
       RenderView("Error",exception.InnerException);
       return false;
    }

    [ControllerAction]
    public void Index()
    {
       int i = 0;
       int sum = 10 / i;

RenderView("Index");
}
}

When the Index Action method will be executed a DevidedByZero Exception will be thrown, when this happens the OnError method will be called and it will render a view and return false to specify that the error was handled.

To make sure to have a common View for displaying the error message, we put it into the Shared subfolder of the Views folder:

/Views
/Shared
Error.aspx

The Error View inherits the ViewData<Exception> class. To make this demo simple I just pass the Exception class to the View and show the value of the Message property:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Error.aspx.cs" Inherits="MvcApplication.Views.Error" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Untitled Page</title>
</head>
<body>
    <div>
        <h1>Error on page</h1>
        <b><%=ViewData.Message %></b>
    </div>
</body>
</html>

ASP.Net MVC Framework - Creating a IRouteHandler which will support Interceptors

Fredrik N — Sun, 18 Nov 2007 23:42:00 GMT

I really love how extensible the ASP.Net MVC Framework is, for example the normal pipeline looks like this:

Request -> Route (IRouteHandler) –> ControlFactory (IControllerFactory) -> Controller (IController) -> ViewFactory (IViewFactory) -> View (IView) -> Response

By implementing my own IrouteHandler I changed the pipeline to support Interceptors before and after an action is invoked:

Request -> Route (IRouteHandler) –> ControlFactory (IControllerFactory) -> (Pre) Interceptors (IInterceptor) -> Controller (IController) -> ViewFactory (IViewFactory) -> View (IView) -> (Post)Interceptors (Iinterceptor) -> Response

On the Controller base class we have two methods, OnPreAction and OnPostAction, those methods will be executed before and after an Action method. But I wanted to be able to specify Interceptors for a Route which should be executed before a controller is instantiated and after a Controller’s action method is executed.

The Interceptors has two methods, PreHandle and PostHandle. The PreHandle returns a value if the process of a request should be stopped or if it should go on with the process of an execution. It’s possible to create a chain of Interceptors. If more than one Interceptor is specified and one of them tells to stop the process, the rest in the chain will not be executed. To specify an Interceptor or a chain of Interceptors I have override the Route class and created my own which has a List of IInterceptors. So when a Route is setup, Interceptors could be added to that route:

RouteTable.Routes.Add(new Nsquared2.MVC.Extenstion.Route
{
   Url = "[controller]/[action]/[id]",
   Defaults = new { action = "Index", id = (string)null },
   RouteHandler = typeof(N2MVCRouteHandler),
   Interceptors = new List<IInterceptors>()
   {
       new MyInterceptor(),
       new AnotherInterceptor()
   }
});

Here is an example of an Interceptor which will redirect the user to a “Not available at this time” page if the current time of the Request is not within a specified interval.

public bool PreHandle(RequestContext context)
{
   if (DateTime.Now.Hour > START_HOUR && DateTime.Now.Hour < END_HOUR)
           return true;
   else
       context.HttpContext.Repsonse.Redirect(“NotAvailableAtThisTime.html”);

return false;
}

The following is my implementation of the MvcHandler’s ProcessRequest to add the Interceptors to the pipeline; the code is also part of my own MvcHandler written in my previous post.

protected override void ProcessRequest(IHttpContext httpContext)
{
if (this.RequestContext == null)
throw new InvalidOperationException("No RequestContext");

   if (base.RequestContext.RouteData.Route.GetType().IsAssignableFrom(typeof(Nsquared2.MVC.Exstension.Route)))
   {
       if (InterceptorHandler.ExecutePreHandler(this.RequestContext))
       {
          ControllerContext controllerContext = this.ExecuteAction();

          InterceptorHandler.ExecutePostHandler(controllerContext);
       }
   }
   else
   {
       this.ExecuteAction();
   }
}

Here is the ExecutePreHandler method of my InterceptorHandler:

public static bool ExecutePreHandler(RequestContext request)
{
Nsquared2.MVC.Extension .Route route = request.RouteData.Route as Nsquared2.MVC.Extension.Route;

   if (route.Interceptors != null)
   {
      foreach (IInterceptors interceptor in route.Interceptors)
         if (!interceptor.PreHandle(request))
           return false;
   }

return true;
}

Note: This code is only used for a Interceptor prototype.