Kenny Tordeur

CSRF prevention in asp.net mvc 6

Wed, 25 Nov 2015 13:45:00 +0000

What is Cross-Site Request Forgery (CSRF)

Cross-Site Request Forgery (CSRF) is an attack that forces an end user to execute unwanted actions on a web application in which they're currently authenticated. CSRF attacks specifically target state-changing requests, not theft of data, since the attacker has no way to see the response to the forged request. With a little help of social engineering (such as sending a link via email or chat), an attacker may trick the users of a web application into executing actions of the attacker's choosing. If the victim is a normal user, a successful CSRF attack can force the user to perform state changing requests like transferring funds, changing their email address, and so forth. If the victim is an administrative account, CSRF can compromise the entire web application. (from www.owasp.org)

How can Asp.Net MVC prevent CSRF

Luckily Asp.Net MVC has a build in mechanisme to fight CSRF attacks. In the previous versions of Asp.Net MVC you used an AntiForgeryToken. You needed to put a ValidateAntiForgeryToken attribute on your MVC action or controller. In the view, you needed to instruct RAZOR to create an AntiForgeryToken. This will give the visitor a cookie called __RequestVerificationToken. This cookie will have the same value as a hidden input field, called __RequestVerificationToken, generated by the Html.AntiForgeryToken() method. This method needed to be placed inside a form tag or the using of a Html.BeginForm().

   public class MyController : Controller
    {
    [HttpPost]
        [ValidateAntiForgeryToken]
        public IActionResult Create(SomeModel model)
        {
          ...
        }
    }

   @using(Html.BeginForm())
   {
    @Html.AntiForgeryToken()
   }

How does Asp.Net MVC 6 prevent CSRF

In the Asp.Net MVC 6 the mechanisme has changed a bit. You still need to put the ValidateAntiForgeryToken attribute on your MVC action, but if you use the build in form taghelper, the forgerytoken will by default be created and placed within the form tag.

   public class MyController : Controller
    {
    [HttpPost]
        [ValidateAntiForgeryToken]
        public IActionResult Create(SomeModel model)
        {
          ...
        }
    }

   <form asp-action="Create">

   </form>

This will result in the following HTML.

<form action="/My/Create/" method="post">

<input name="__RequestVerificationToken" type="hidden" value="CfDJ8DCDWZ4iOzZDmNKl5HFAUd2qQe4qwOhVP4znwDlTDINNK_h-1a2v0A1aDPCdb4lEgc9X_cTsjKkCDUCYh9EKr7HqXI3hvIRfnRItwfJwbImCZIx38uDfwVu5jzdVZOcaXUUmoPBDtG6-0__0FVezb-U" />
</form>

If you don't want the forgerytoken to be created you can pass a false value to the form taghelper for the antiforgery parameter.

   <form asp-action="Create" asp-antiforgery="false>

   </form>

Taghelpers and Dependency Injection

Thu, 15 Oct 2015 08:14:00 +0000

I was wondering if you could use Dependency Injection for taghelper. I'll modify the example used in this my previous post Creating a custom taghelper.

Creating a service to inject

    public interface IPersonService
    {
        string GetName();
    }

    public class PersonService : IPersonService
    {
        public String GetName()
        {
            return "PersonService.GetName()";
        }
    }

Register this class in the Dependency Injection system of Asp.net. Add it to services collection in the ConfigureServices method from the Startup class.

  public void ConfigureServices(IServiceCollection services)
  {
        services.AddTransient<IPersonService, PersonService>();
  }

Modifying the Asp.Net mvc taghelper

    [TargetElement("Person")]
    public class MyTagHelper : TagHelper
    {
        IPersonService _personService;

        public MyTagHelper(IPersonService personService)
        {
            _personService = personService;
        }

        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            output.Content.SetContent(_personService.GetName());

            base.Process(context, output);
        }
    }

Testing

When I run the application, the DI-system will also inject dependencies for my custom taghelper.

Creating a custom taghelper

Wed, 14 Oct 2015 08:14:00 +0000

What are taghelpers?

Basically taghelpers do the same thing as the htmlhelpers we all know in Asp.net MVC. If you use a htmlhelper in your view, you'll see that it is actually C# code. If you would use a taghelper, it would lean more to html than to C# code.

Defining your taghelper

Your custom taghelper will need to inherit from the TagHelper base class. This base class defines two virtual methods called Process and ProcessAsync. In these methods you'll write your taghelper logic.

    public class MyTagHelper : TagHelper
    {
        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            base.Process(context, output);
        }
    }

In order to use your taghelper, i'll need to register it. This done in the "_ViewImports.cshtml" file that can be found in the View folder.

      @addTagHelper "MyWebApplication.MyTagHelper, MyWebApplication"

The last part is your dll name. The first part is the name (namespace + classname) of the taghelper you want to register. If you want to register all the taghelpers from a specific dll you can use a wildcard.

      @addTagHelper "*, MyWebApplication"

When you succesfully have registered your taghelper, i'll get intellisense for your taghelper in your views.

Next, you will need to specify a target html tag that will invoke your custom taghelper. This can be done in 2 ways:

by naming convention
- If your your taghelper is called TestTagHelper, it will target all Test-tags

using the TargetElement attribute
- you explicitly set the target tag

    [TargetElement("Person")]
    public class MyTagHelper : TagHelper
    {        
        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            base.Process(context, output);
        }
    }

Adding attributes/properties on a taghelper

I now want to pass a name and lastname to the custom taghelper. These parameters will be passed like this:

<Person name="kenny" lastname="tordeur"></Person>

In the taghelper you will need to define these attributes. This can be done using the TargetElement tag.

    [TargetElement("Person",Attributes = "name,lastname")]
    public class MyTagHelper : TagHelper
    {        
        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            base.Process(context, output);
        }
    }

In order to get the values of the attributes, you can use the TagHelperContext. This object will contain all the defined attributes. You can also create properties that will map to the attribute names.

    [TargetElement("Person",Attributes = "name,lastname")]
    public class MyTagHelper : TagHelper
    {
        public string Name { get; set; }

        public string Lastname { get; set; }

        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            base.Process(context, output);
        }
    }

To map the attribute values to the correct properties, a naming convention is used. The attribute "name" will map to the property "Name". So the first letter of the attribute will be transformed to an uppercased letter. If you would have an attribute "last-name", it would be mapped to "LastName" property. So the "-" will be remove from the attribute name and the next letter will be transformed to an uppercased letter.

You aren't just limited by passing in simple types (string, int, ...) to the taghelper. You can also pass complex types to the taghelper.

Rendering some html

The only thing left to do is to implement an output for the taghelper. This can be done using the TagHelperOutput object. This object contains everything you need to create your custom html output. In this example i'll just concatent the Name with the Lastname.

    [TargetElement("Person",Attributes = "name,lastname")]
    public class MyTagHelper : TagHelper
    {
        public string Name { get; set; }

        public string Lastname { get; set; }

        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            output.Content.SetContent($"{Name}, {Lastname}");

            base.Process(context, output);
        }
    }

The result

I've but this in my view.

    <Person lastname="Tordeur" name="Kenny"></Person>

The intellisense helped me.

This is the output when the view is rendered in the browser.

    <Person>Kenny, Tordeur</Person>

Injecting a service in a view

Mon, 11 May 2015 08:14:00 +0000

In the ASP.NET MVC 6, you can now use the @inject keyword. This allows you to inject a service (class) into your view. This class must be public, non-nested and non-abstract.

The @inject needs 2 "parameters" in order to work.

@inject [name of your class] [variable name that can be used in your view]

My Qoutes service

This is the class that i want to inject into my view.

using System.Collections.Generic;
using System;

namespace VSCode1.Models
{
    public class Quotes
    {
        List<string> _quotes = new List<string> { 
            "Don't cry because it's over, smile because it happened",
            "Be yourself; everyone else is already taken.",
            "Two things are infinite: the universe and human stupidity; and I'm not sure about the universe."    
         };

        public string GetRandomQuote()
        {
            Random r = new Random();                
            return _quotes[r.Next(0, _quotes.Count - 1)];
        }

        public List<string> GetQuotes()
        {
            return _quotes;
        }
    }
}

Putting it in my view

To use the service in my view, i add the inject statement on top of the view. "quotes" can be used a variable in this view and is of type "VSCode1.Models.Quotes".

@inject VSCode1.Models.Quotes quotes

<h1>@quotes.GetRandomQuote()</h1>

@foreach(var quote in quotes.GetQuotes())
{
    <h2>@quote</h2>
}

Registering your service in your application

If i run my application, i would get an error saying that there is no service for type VSCode1.Models.Quotes.

When you use @inject, the runtime will use dependency injection to inject the type you requested. So your type needs to be registered in the dependency injector. This needs to be done in the startup.cs file.

        public void ConfigureServices(IServiceCollection services)
        {
            //other stuff ...

            services.AddTransient<VSCode1.Models.Quotes>();
        }

Now the View renders without error.

What's new in C# 6.0: Productivity

Thu, 02 Apr 2015 08:14:00 +0000

Version 6 of C# contains a bunch of new feature that allows to speed up the productivity of the developer.

Feature 1 : static usings

The classes are structured by their usings. If you need a specific class, you'll need to add a using containing the namespace of that class. If you do this, you'll get access to all the classes that are defined in that using. With static usings, you can bring only a specific class into "scope" which will you access to all of it's static methods.

Consider following console application.

using System;

namespace ConsoleApplication8
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello world");
        }
    }
}

If i use a static using for the "Console" class, i can do this.

using static System.Console;

namespace ConsoleApplication8
{
    class Program
    {
        static void Main(string[] args)
        {
            WriteLine("Hello world");
        }
    }
}

Feature 2 : ? a.k.a the elvis operator

Consider following object graph.

    public class ObjectA
    {
        public ObjectB ObjectB { get; set; }
    }

    public class ObjectB
    {
        public ObjectC ObjectC { get; set; }
    }

    public class ObjectC
    {
        public string Name { get; set; }
    }

If you want to access the "Name" property of "ObjectC" via ObjectA, i'll write code that looks like this.

    public void SomeMethod(ObjectA objectA)
    {
        string name = null;

        if (null != objectA.ObjectB)
            if (null != objectA.ObjectB)
                if (null != objectA.ObjectB.ObjectC)
                    name = objectA.ObjectB.ObjectC.Name;
    }

I'll needs those if-statements because you don't know if the child object isn't null. With the elvis operator ? you can remove all the if-statements and make the code a little more readable.

    public void SomeMethod(ObjectA objectA)
    {
        string name = objectA?.ObjectB?.ObjectC?.Name;
    }

If one of the child objects is null, we'll get the default value for a "string" object.

Feature 3: Expression Bodied Members

Expression Bodies Members give you the possibility to write short methods even shorter.

    public class ObjectC
    {
        public string Name { get; set; }

        public override string ToString()
        {
            return Name;
        }
    }

The "ToString" method can be writing shorter using expressions.

    public class ObjectC
    {
        public string Name { get; set; }

        public override string ToString() => Name;
    }

You can only do this for expression on a single line. If you would write it like this, it won't build and Visual Studio will give build errors.

    public class ObjectC
    {
        public string Name { get; set; }

        public override string ToString() =>  
        {
            return Name;
        }
    }

Submitting to different controller actions in ASP.NET MVC

Mon, 09 Mar 2015 08:14:00 +0000

When you create a view in ASP.NET MVC, you'll probably have 2 methods for that view in your controller. A HTTPGET method and a HTTPPOST method that will accept your form data. This POST method will do some sort of action. Now sometimes you wish, that you could put 2 submit buttons in the same form that will submit to 2 different actions on your controller.

Solution one: Javascript to the rescue

You could use javascript to modify the action of your form. You'll add a click event on the submit button and overwrite the default submit action.

<html>
 <body>
    <form id="myform">
           <input type="submit" id="submit1"/>
           <input type="submit" id="submit2"/>
    </form>
 </body>
 <script>
    $("#submit1").click(function() {
    document.myform.action = “http://localhost/controller/action1”;
    });
    $("#submit2").click(function() {
      document.myform.action = “http://localhost/controller/action2”; 
    });
 </script>
</html>

Solution two: Creating a custom ActionNameSelector attribute

You can create a custom ActionNameSelector. This will select the correct action on your controller based on the value of your submit button. You can find a detailed blog post by Maarten Balliauw.

Solution three: HTML 5 to the rescue

You can add a formaction action attribute on your submit button. This form attribute specifies where the form data needs to be sended when you click on the submit button.

<html>
 <body>
    <form id="myform">
           <input type="submit" formaction="/controller/action1"/>
           <input type="submit" formaction="/controller/action2"/>
    </form>
 </body>
</html>

The downside of this solution, is that it isn't supported by all browsers.

ASP.NET VNext: Routing constraints and custom constraints

Fri, 11 Jul 2014 13:37:00 +0000

In ASP.NET VNext the routing system has been unified and it is build as a middleware component that easily can be plugged in. This routing system can be found in the “Microsoft.AspNet.Routing” Nuget Package or add github if you want to work with the source code.

Constraints

Here is an example how we putted constraints on our route parameters in MVC 5. In this case the parameter “productId” must match an integer.

routes.MapRoute(
    "Product", 
    "Product/{productId}", 
    defaults: new { controller = "Product", action = "Details" }, 
    constraints: new { productId = @"\d+" });

ASP.NET VNext introduced a new syntax for defining constraints:

“{parameter:constraint}”

parameter will contain the name of the parameter you want to constraint and constraint will specify with constraint will be applied.

For a full overview of the available constraints you can take a look at Microsoft.AspNet.Routing/Constraints.

So the previous constraint will look like this in ASP.NET VNext.

routes.MapRoute(
    "Product", 
    "Product/{productId:int}", 
    new { controller = "Product", action = "Details" });

You also can make the parameter “nullable” using “{parameter:constraint?}” syntax.

routes.MapRoute(
    "Product", 
    "Product/{productId:int?}", 
    new { controller = "Product", action = "Details" });

Or pass in a default value “{parameter:constraint=value}”.

routes.MapRoute(
    "Product", 
    "Product/{productId:int=1}", 
    new { controller = "Product", action = "Details" });

Adding your custom constraints

If the buildin constraints don’t meet your needs, you can also create a custom constraint based on the IRouteConstraint interface.

public class AreYouLuckyRouteConstraint : IRouteConstraint
{
    public bool Match(HttpContext httpContext, IRouter route, string routeKey, IDictionary<string, object> values, RouteDirection routeDirection)
        {
            object value;
            if (values.TryGetValue(routeKey, out value) && value != null)
            {
                int result;
                var valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                var isInt =  Int32.TryParse(valueString, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);


            if(isInt)
            {
                Random rand = new Random(10);
                return result == rand.Next(100);
            }
            else
            {
               return false;
            }
        }
        return false;
    }
}

This route constraint will test how lucky you are and will only pass when you passed a correct integer value between the number 0 and 100. Now we need to add our custom constraint to the application route options in the Startup class.

    var routeOptions = app.ApplicationServices.GetService<IOptionsAccessor<RouteOptions>>();
    routeOptions.Options.ConstraintMap.Add("areyoulucky", typeof(AreYouLuckyRouteConstraint));

Now you can use your custom constraint.

routes.MapRoute(
    "Product", 
    "Product/{productId:areyoulucky}", 
    new { controller = "Product", action = "Details" });

ASP.NET vNext: Managing dependencies using the project.json file

Wed, 02 Jul 2014 08:26:00 +0000

In ASP.NET vNext your dependencies, configurations aren't configured in the .csproj file like before. They added a project.json file where all this is done. This file is a simple JSON file that is much more readable than the .csproj file.

Adding Dependencies

Dependencies are defined using a name and version.

And Visual Studio provides full intellisense to add dependencies.

You can use wildcard to get latest version of a specific set.

If you always want the latest version, you'll need to specify an empty string.

Resolving dependencies in runtime

When the runtime need to resolve a dependency, there is a chain of loaders the runtime uses to decide what it needs to load. Their will be a loader that will look for a Nuget Package, another will look for a project and another will look for assemblies on the disk. The main goal was to make Nuget packages the primary goal of reference. If you add Nuget Packages as a reference, ASP.NET will fetch those packages when you first deploy and run your application.

Asp.net MVC: The correct way to render a partialview

Fri, 24 Jan 2014 13:51:00 +0000

When you create an Asp.net mvc application will create partial views in order to use them as "user controls" throughout your application. But you have to use them with caution.

These are my viewmodels.

    public class ParentViewModel
    {
        public string Description { get; set; }

        public ChildViewModel Child { get; set; }

        public ParentViewModel()
        {
            Child = new ChildViewModel();
        }
    }

    public class ChildViewModel
    {
        public string Description { get; set; }
    }

The ChildViewModel will be used on other different views, so I'll create a partial view for it. So my index.cshtml will look like this.

But when I submit my form, I won't get a Description for my ChildViewModel on the controller site. This is because the partial view for my ChildViewModel doesn't render like it should. The generate name for the Description field is wrong.

The "Child" prefix isn't added to the Description field so the modelbinder doesn't know that this is a property of the ChildViewModel. Now when I convert my partial view to an editor template and use the EditorFor method the prefix will be added automatically.

The EditorFor method will actually add a "TemplateInfo" key to the ViewData of the editor template. This key will contain an instance of System.Web.Mvc.TemplateInfo. This object contains a HtmlFieldPrefix property that will be used by the TextBoxFor methode in order to generate the correct name.

So if we want to use the Partial method we'll need to pass a ViewDataDictionary with a TemplateInfo key that will contain the correct HtmlFieldPrefix.

Conclusion

If your partialview needs to post data to the controller, I would suggest to transform your partialview to an editor template and use the EditorFor method. This will generate the correct HtmlFieldPrefix for you. But if you need to show a list and you need unique names. I would iterate the list and pass in a custom TemplateInfo to the Partail method for each item in the list. If you only need to show data you can use partial method.

Navigation in a Single page Web application: Sammy.js

Tue, 08 Jan 2013 12:15:00 +0000

Single page Web applications are becoming more and more frequent. There are a lot of frameworks/technologies that make the development of these applications a lot easier. You can use JQuery to manipulate your page, use Knockout.js to work the ViewModel way and use WebApi to get your data. All these tools make a fine toolbox to create responsive, single page web applications.

But how about the navigation in these applications? How can this be done in a pluggable, centralized way? You can easily create a JavaScript function on your page that will accept an id of a view that you want to show. This function will then hide all the others views, maybe using JQuery and some sort of animation, and then make the view you requested visible.

<body>
    <a href="#" onclick="javascript:navigate('page_1')">Show Page 1</a>
    <a href="#" onclick="javascript:navigate('page_2')">Show Page 2</a>

    <div class="page" id="Div1" style="display: none">
        <h1>Page 1</h1>
        Lorem ipsum dolor sit amet, eos augue fierent id. Quo nonumes blandit ei, ut sensibus contentiones per.
        Nam te aliquam salutandi, sit at congue pertinax adversarium, eam putent verear laboramus ad. Ut viderer 
        legimus singulis duo, mel propriae volutpat ad. Mea suscipit gloriatur id, vel cu harum scaevola appetere.
    </div>

    <div class="page" id="Div2" style="display: none">
        <h1>Page 2</h1>
        Lorem ipsum dolor sit amet, eos augue fierent id. Quo nonumes blandit ei, ut sensibus contentiones per. 
        Nam te aliquam salutandi, sit at congue pertinax adversarium, eam putent verear laboramus ad. Ut viderer 
        legimus singulis duo, mel propriae volutpat ad. Mea suscipit gloriatur id, vel cu harum scaevola appetere.
    </div>

    <script type="text/javascript">
        function navigate(viewId) {
            $(".page").hide();

            $("#" + viewId).show("slow");
        }

    </script>
</body>

Now you have a function that is centralized and that actually is responsibly for showing the correct page (view). It acts like an ViewController. I'm not saying that this is a bad way of working, but there is one problem with this solution. The state of witch page was active isn’t maintained. This means that you can't bookmark a specific page or send it to an external user. This is where Sammy.js comes to the rescue.

Sammy.js

Sammy.js is a small JavaScript framework that enables you to create routes in your page ( looks a lot like routes in MVC ). You can install it using Nuget.

<body>
    <a href="#page_1">Show Page 1</a>
    <a href="#page_2">Show Page 2</a>

    <div class="page" id="page_1" style="display: none">
        <h1>Page 1</h1>
        Lorem ipsum dolor sit amet, eos augue fierent id. Quo nonumes blandit ei, ut sensibus contentiones per.
        Nam te aliquam salutandi, sit at congue pertinax adversarium, eam putent verear laboramus ad. Ut viderer 
        legimus singulis duo, mel propriae volutpat ad. Mea suscipit gloriatur id, vel cu harum scaevola appetere.
    </div>

    <div class="page" id="page_2" style="display: none">
        <h1>Page 2</h1>
        Lorem ipsum dolor sit amet, eos augue fierent id. Quo nonumes blandit ei, ut sensibus contentiones per. 
        Nam te aliquam salutandi, sit at congue pertinax adversarium, eam putent verear laboramus ad. Ut viderer 
        legimus singulis duo, mel propriae volutpat ad. Mea suscipit gloriatur id, vel cu harum scaevola appetere.
    </div>

    <script type="text/javascript">
        $(function () {
            Sammy(function () {
                this.get('#:page', function () {
                    var pageId = this.params.page;
                    navigate(pageId);
                });
            }).run();
        });

        function navigate(viewId) {
            $(".page").hide();
            $("#" + viewId).show("slow");
        }
    </script>

With Sammy.js, i created a route "#:page" where ":page" is actually a parameter. In the links, i removed the onclick attribute and added some href information. When you now click on the link, this information will be added to the url. Sammy.js will see this, and will try to match this to its predefined routes. It will then resolve the parameter from the url and pass it to the navigate function.

The end result is still the same but now the "state"; is added to the url so you can bookmark it or send it as a link.

The solution can be downloaded here.

Asp.net MVC MEF: Per Request Lifetime

Fri, 21 Dec 2012 07:52:00 +0000

Like the title says, i want to use MEF in an Asp.Net MVC application and the lifetime of the object has to be exactly the same as the lifetime of the request. In short, i want 1 single unique object that is recreated per request.

In MEF there is a way to control the lifetime of the created object. This is specified the PartCreationPolicy attribute that you can use to decorate the object. In my test project i installed the nuget package i created in this post to incorporate MEF in an Asp.net MVC application. I also created an object called MyCustomObject with an interface IMyCustomObject. This object has only one property called Created that contains the date when the object is created. In the constructor of that object i have but an thread.sleep. This way i am sure that the Created property will be different for every created object.

  public interface IMyCustomObject
  {
      DateTime Created { get; set; }
  }

  [Export(typeof(IMyCustomObject))]    
  public class MyCustomObject : IMyCustomObject
  {
       public DateTime Created { get; set; }

       public MyCustomObject()
       {
           Created = DateTime.Now;
           System.Threading.Thread.Sleep(1000);
       }
  }

I also created an object called MyCustomObjectContainer. This object will contain a property of the type IMyCustomObject.

 [Export]   
 public class MyCustomObjectContainer
 {
     [Import]
     public IMyCustomObject MyCustomObject { get; set; }
 }

The controller will have 2 properties. The first of type IMyCustomObject aand the other of type MyCustomContainer. In the action method of the controller, i will write the Created value that is found in those 2 properties to the viewbag. That way i will be sure if the application is using the same object.

  [Export]
  [PartCreationPolicy( CreationPolicy.NonShared)]
  public class HomeController : Controller
  {
      [Import]
      public IMyCustomObject MyCustomObject { get; set; }

      [Import]
      public MyCustomObjectContainer MyCustomObjectContainer { get; set; }

      public ActionResult Index()
      {
          this.ViewBag.MyCustomtObjectDateCreated = MyCustomObject.Created;
          this.ViewBag.MyCustomObjectContainerDateCreated = MyCustomObjectContainer.MyCustomObject.Created;
          return View();
      }       
  }

Choosing the right PartCreationPolicy

In MEF there are 3 different type of creation policies that we can choose. More information can be found here.

Shared: the part author is telling MEF that at most one instance of the part may exist per container.
NonShared: the part author is telling MEF that each request for exports of the part will be served by a new instance of it.
Any or not supplied value: the part author allows the part to be used as either "Shared" or "NonShared".

The Shared Creation policy

We will set Creation policy to Shared and run the application.

We see that the same instance of the MyCustomOject is used. But when we refresh the page, we will get exactly the same value, over and over again. So this is not the behavior that we want.

The NonShared Creation Policy

We will set the creation policy to NonShared.

With every refresh, we will get a different value for the Created property, but everytime that an IMyCustomObject is asked form the MEF container, a new value is created so this is not a solution for my problem.

The solution

We can create a solution for this problem using the Proxy-pattern, HttpContext and ExportFactory.

The ExportFactory class was introduced in MEF 2. It allows us to create new instances and control the lifetime of those instances. This will be perfect to create the MyCustomObject object since we need to control the lifetime of this object.

The HttpContext contains Http information about an HttpRequest. There is one property that is very interesting in our case, the Items property. This property is in fact a dictionary where you can insert objects into. This collection is cleared with every request (perfect). We will use this dictionary to add the created MyCustomObject. So every time that this object is requested, we will look in this dictionary. When it is not found, the ExportFactory will create it and add it to the dictionary.

The proxy pattern will be used to make this a transparent as possible.

The Implementation

I'll create an IItemContainer that has one property Container of type IDictionary. Then i'll create an HttpContextContainer that will implement this interface. This object will map the Container property to the HttpContext.Items property.

public interface IItemContainer
{
  IDictionary Container { get; }
}

[Export(typeof(IItemContainer))]
[PartCreationPolicy(CreationPolicy.Shared)]
public class HttpContextContainer : MEF_Asp.Net_MVC_Per_Request.Models.IItemContainer
{
    public IDictionary Container
    {
        get
        {
          return HttpContext.Current.Items;
        }
    }       
}

Next I'll create the proxy object (MyCustomObjectPerRequest). This object will contain the IItemContainer and the Exportfactory instances and implement the IMyCustomObject. This object will be served by the MefContainer when something is request of type IMyCustomObject.

    [Export(typeof(IMyCustomObject))]
    public class MyCustomObjectPerRequest : IMyCustomObject
    {
        [Import]
        public ExportFactory<MyCustomObject> Factory { get; set; }

        [Import]
        public IItemContainer ItemContainer { get; set; }

        private IMyCustomObject MyCustomObject
        {
            get
            {
                if (null == ItemContainer.Container["MyCustomObject"])
                {
                    ItemContainer.Container["MyCustomObject"] = Factory.CreateExport().Value;
                }

                return (IMyCustomObject)ItemContainer.Container["MyCustomObject"];
            }
        }

        public DateTime Created
        {
            get
            {
                return MyCustomObject.Created;
            }
            set
            {
                MyCustomObject.Created = value;
            }
        }
    }

We also need to change the ExportAttribute on the MyCustomObject class so that it doesn't specify a ContractType.

    [Export] 
    public class MyCustomObject : IMyCustomObject

The Result

When we know run the application, we will use the same MyCustomObject object per request. When we refresh, we'll get an other instance.

Conclusion

This solution can also be used to use the same instance per Session or to incorporate a caching mechanism. All that needs to been done is to implement the IItemsContainer and map the Container property. The Visual Studio solution can be downloaded here.

Asp.net MVC: reuse Areas from external project

Sun, 16 Dec 2012 14:35:00 +0000

I created a MVC project that has an Area defined that i would like to use in an other MVC project. Here is the structure.

I created a reference between the AlphaArea and MainApp project. When i run the application is see that the area registration of the AlphaArea is executed. But when i try to go to the area i get an error.

What this error says, is that the view for the Index of the AlphaController in the Alpha area isn’t found. This makes perfect sense because the Index view isn’t declared in the MainApp project and this is where MVC tries to find the view. We need to make sure that the view engine can resolve the view.

There are a couple solutions to resolve this. We could copy or create a link in the MainApp to the index view that is defined in the AlphaArea. We would need to copy the whole Area structure. Don’t know about you but I'm not really found of that solution. An other solution is to compile the AlphaArea views in the DLL. This can be done by a Visual Studio extension and a Nuget package.

First you need to install the Razor Generator extension for Visual Studio.

This extension will create a .cs file for a view, but in the properties of that view, the Custom Tool needs to be set to “RazorGenerator”. Otherwise the VS extension will not create a .cs file for that view.

When we compile the project, the view will be added to the DLL of the AlphaArea project. This isn’t enough. Now we need a way to tell the view engine that the view can be found in the DLL. Luckily, there is a Nuget package that does the trick. You simply need to install the package “RazorGenerator.Mvc” in the AlphaArea project.

This package will add a file (RazorGeneratorMvcStart) in the AppStart folder. This file will create a PrecompiledMvcEngine and add it to the ViewEngines. The code will be executed when the applications starts. This is done by using the WebActivator.

using System.Web;
using System.Web.Mvc;
using System.Web.WebPages;
using RazorGenerator.Mvc;

[assembly: WebActivator.PostApplicationStartMethod(typeof(AlphaArea.App_Start.RazorGeneratorMvcStart), "Start")]

namespace AlphaArea.App_Start {
    public static class RazorGeneratorMvcStart {
        public static void Start() {
            var engine = new PrecompiledMvcEngine(typeof(RazorGeneratorMvcStart).Assembly) {
                UsePhysicalViewsIfNewer = HttpContext.Current.Request.IsLocal
            };

            ViewEngines.Engines.Insert(0, engine);

            // StartPage lookups are done by WebPages. 
            VirtualPathFactoryManager.RegisterVirtualPathFactory(engine);
        }
    }
}

When we now run the application and go to the Alpha area, the view is resolved.

The same system can also be used on Controllers in external projects. The example for the post can be downloaded here.

Web Api: Passing a Complex type in JSON

Wed, 12 Dec 2012 20:25:00 +0000

In one project i wanted to pass a complex type to the Post method of an Web Api controller. The Post itself will be done using JQuery in the JSON format. I noticed that the parameter was always null. After a bit of searching i found the solution.

The Set Up

Server side

public class ValuesController : ApiController
    {
        // POST api/values
        public void Post(MyComplexType value)
        {
        }       
    }

    public class MyComplexType
    {
        public string Name { get; set; }

        public MyComplexSubType MyComplexSubType { get; set; }
    }

    public class MyComplexSubType
    {
        public int Age { get; set; }
    }

Client Side

<script type="text/javascript">

        function MyComplexSubType()
        {
            var self = this;

            self.Age = 26;
        }

        function MyComplexType()
        {       
            var self = this;

            self.Name = "Kenny Tordeur";
            self.MyComplexSubType = new MyComplexSubType();
        }


        function PostComplexType()
        {
            $.ajax("/api/values", {
                data: JSON.stringify(new MyComplexType()),
            contentType: 'application/json',
            type: 'POST',
            success: SendComplexTypeCallBack
        });
        }


        function SendComplexTypeCallBack(data)
        {
            alert("Complex type sended");
        }
    </script>

The PostComplexType will be trigged by a click event on a button. It will create a javascript object called MyComplexType. This object will map directly to the object we created on the server side.

The missing link

With this set-up the parameter will always be null. We need to add a line of code to the global.asax.

ValueProviderFactories.Factories.Add(new JsonValueProviderFactory());

Value providers are used by the model binding system in MVC to populate the values of model objects. We basically add a provider that enables to bind a model to a JSON model. The solution can be downloaded here.

WebApi: File upload and download using JQuery and submit button

Fri, 07 Dec 2012 09:15:00 +0000

I am going to create a WebApi service called FileService that can be used to upload and download files. The service will only contain 2 methods. A Post to upload and a Get method that accepts an id parameter to identify the file that needs to be downloaded. Let’s start with the Post method.

The Post method

This method will look in the Request object to see if there are any posted files. If so, it will loop over the files and create them on the server side. The server will return a 201 HttpStatus and a list of strings that will contain the full path of the file(s) at server side. When there are no files posted, the service will return a 401 status a.k.a. BadRequest.

public HttpResponseMessage Post()
       {
           HttpResponseMessage result = null;
           var httpRequest = HttpContext.Current.Request;

           // Check if files are available
           if (httpRequest.Files.Count > 0)
           {
               var files = new List<string>();

               // interate the files and save on the server
               foreach (string file in httpRequest.Files)
               {
                   var postedFile = httpRequest.Files[file];
                   var filePath = HttpContext.Current.Server.MapPath("~/" + postedFile.FileName);
                   postedFile.SaveAs( filePath);

                   files.Add(filePath);
               }

               // return result
              result = Request.CreateResponse(HttpStatusCode.Created, files);
           }
           else
           {
               // return BadRequest (no file(s) available)
               result = Request.CreateResponse(HttpStatusCode.BadRequest);
           }

           return result;
       }

The Get Method

As mentioned before, the Get Method will accept a string file that will identify (= filename) the file that needs to be downloaded.

public HttpResponseMessage Get(string id)
       {
           HttpResponseMessage result = null;
           var localFilePath = HttpContext.Current.Server.MapPath("~/" + id);

           // check if parameter is valid
           if (String.IsNullOrEmpty(id))
           {
               result = Request.CreateResponse(HttpStatusCode.BadRequest);
           }
               // check if file exists on the server
           else if (!File.Exists(localFilePath))
           {
               result = Request.CreateResponse(HttpStatusCode.Gone);
           }
           else
           {// serve the file to the client
               result = Request.CreateResponse( HttpStatusCode.OK);
               result.Content = new StreamContent(new FileStream(localFilePath, FileMode.Open, FileAccess.Read));
               result.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment");
               result.Content.Headers.ContentDisposition.FileName = id;
           }

           return result;
       }

Uploading a File

Using a submit button

 <form name="form1" method="post" action="api/file" enctype="multipart/form-data">
    <div>
        <label>
            Using submit</label>
        <input name="myFile" type="file" />
    </div>
    <div>
        <input type="submit" value="Submit" />
    </div>
    </form>

Using JQuery

<form enctype="multipart/form-data">
    <label>
        Using JQuery</label>
    <input name="file" type="file" />
    <input type="button" id="Upload" value="Upload" />
    </form>

        <script type="text/javascript">
            $(function () {
                $('#Upload').click(function () {
                    var formData = new FormData($('form')[0]);
                    $.ajax({
                        url: 'api/file', 
                        type: 'POST',
                        // Form data
                        data: formData,
                        //Options to tell JQuery not to process data or worry about content-type
                        cache: false,
                        contentType: false,
                        processData: false
                    });
                });
            });
        </script>

Downloading a File

Summary

The solution can be downloaded here.

Paged Grid with Knockout.js and WebApi

Sat, 01 Dec 2012 19:09:00 +0000

I want to see how easily you can create a custom grid that uses an WebApi as datasource and that allows the user to page the data and also allow them to choose a page size for the grid.

The WebApi

The WebApi will return a viewmodel that contains an array of names (string) and a property that specifies how many pages that there are available.

public class NamesGridViewModel
    {
        public IEnumerable<String> Names { get; set; }

        public int NumberOfPages { get; set; }
    }

The WebApi itself will contain a method that accepts 2 parameters. The parameters will be page (the page that we request) and pagesize (how many entries a page contains). This method will be responsible for calculating how many pages there are and to serve the requested names based on the 2 parametes.

public class ValuesController : ApiController
    {
        public IList<String> Names
        {
            get { return new List<String> { "Fred", "Barney", "Betty", "Wilma", "Bart", "Lisa", "Maggie", "Homer", "Marge" }; }
        }
            
        public NamesGridViewModel Get(int page, int pagesize)
        {
            return new NamesGridViewModel
                       {
                           // get the request names for the specific page
                           Names = (0 == page? null : Names.Skip((page - 1)*pagesize).Take(pagesize).ToArray())
                           ,
                           // calculated number of pages and ceil the value
                           NumberOfPages = ((int) Math.Ceiling((double) Names.Count/pagesize))
                       };
        }
    }

The client

The client will need a reference to kockout.js. With knockout.js it is possible to apply the MVVM pattern and also work with templates in javascript.

The UI

Page size: <select data-bind="options: availablePageSize, optionsText: $data, value: selectedPageSize"></select><!-- the grid --><table data-bind="with: namesGridViewModel">
    <thead>
        <tr>
            <th>
                Name
            </th>
        </tr>
    </thead>
    <tbody data-bind="foreach: Names">
        <tr>
            <td data-bind="text: $data">
            </td>
        </tr>
    </tbody>
</table><!--Contains the page links--><div id="pager"></div>

The Javascript

<script type="text/javascript">
    // Our  ViewModel.
    function pageViewModel() {
        var self = this;
        self.namesGridViewModel = ko.observable(); // contains the viewmodel returned by the WebApi
        self.selectedPageSize = ko.observable(3); // contains the selected page size, default value is 3
        self.availablePageSize = ko.observableArray([1, 2, 3, 4, 5]); // contains the available page sizes a user can select
        self.selectedPage = ko.observable(1); // contains the selected page

        // Add a click event to all future element with a class "pageIndex". This event will fire
        // when the user clicks a specific page.
        $("#pager").on("click", ".pageIndex", function (event) {
            // set the selected page in the viewModel
            self.selectedPage($(this).text());
        });

        // This function will be used to get the data from our WebApi. The requested page and page size are passed
        // as a parameter. The result will be stored in the namesGridViewModel property. This will cause that the subscribe event
        // for the namesGridViewModel will be fired ==> the page links will be created.
        self.navigate = function () {
            $.get("/api/values?page=" + self.selectedPage() + "&pagesize=" + self.selectedPageSize(), self.namesGridViewModel);
        };

        // Function that will subscribe to all the needed events.
        self.SubscribeToEvents = function () {

            // This event will fire when selectedPageSize is changed.
            self.selectedPageSize.subscribe(function (newValue) {
                self.selectedPage(1);
                self.navigate();
            });

            // This event will be fired when the selectedPage is changed.
            self.selectedPage.subscribe(function (newValue) {
                self.navigate();
            });

            // This event will fire when a new value is defined for the namesGridViewModel.
            // It will create the page links below the grid.
            self.namesGridViewModel.subscribe(function (newValue) {
                var numberOfPages = newValue.NumberOfPages;
                var $pager = $("#pager");
                // clear the pager
                $pager.html("");
                // created the pages the user can click on
                for (var i = 1; i <= numberOfPages; i++) {
                    var link = $('<a class="pageIndex">' + i + '</a>');
                    $pager.append(link);
                }
            }, this);
        };
        
        // This function will be used to kick start everything.
        self.bind = function () {
            self.SubscribeToEvents();
            self.navigate();
            ko.applyBindings(self);
        }
    }
    // Create the viewModel and bind it.
    $(function () { new pageViewModel().bind(); })</script>

The result

Summary

You have seen how to create a basic paging grid using Knockout.js.You can easily extend this example to also allow sorting. The solution can be downloaded here.

Nuget package: integrated MEF in Asp.Net MVC 4 and WebApi

Wed, 28 Nov 2012 12:26:00 +0000

Today i wanted to create my first Nuget package and i already knew what i would publish to the world. I wanted to make the code that is used to use MEF in Asp.Net MVC 4 and the WebApi ([view this post](http://blog.kennytordeur.be/2012/08/31/mef-in-aspnet-mvc-4-and-webapi)) easy to reuse in other projects. I rewrote the code in a class libary.
After a little google-ing i found a video that explained how to create a Nuget package using the Nuget Package Explorer. After that i created a user at the Nuget gallery so i got my API Key. With this, i had all the information i needed to published my first Nuget package and i have a feeling that it will not be my last :-)
The package can be installed from the Package Manager Console by typing: Install-Package MEF.MVC4

MEF in Asp.Net MVC 4 and WebApi

Fri, 31 Aug 2012 12:00:00 +0000

MEF stands for “Microsoft Extensibility Framework”. If you want an overview of MEF, you can look here. In this post we will integrated MEF with Asp.Net MVC 4 and with the WebApi.

Asp.Net MVC 4

First of all you need to reference the “System.ComponentModel.Composition.dll” assembly which contains the implementation of MEF. Now where are going to create a MEF controller factory. Like the name says, it will be responsible to create the controller that is requested.

public class MefControllerFactory : DefaultControllerFactory
   {
       private readonly CompositionContainer _compositionContainer;

       public MefControllerFactory(CompositionContainer compositionContainer)
       {
           _compositionContainer = compositionContainer;
       }

       protected override IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType)
       {
           var export = _compositionContainer.GetExports(controllerType, null, null).SingleOrDefault();

           IController result;

           if (null != export)
           {
               result = export.Value as IController;
           }
           else
           {
               result = base.GetControllerInstance(requestContext, controllerType);
               _compositionContainer.ComposeParts(result);
           }
         
           return result;
       }
   }

The MefcontrollerFactory will inherit from the DefaultControllerFactory and has a constructor that accepts a CompositionContainer. To plug in MEF, the GetControllerInstance methode will be overridden. First will look in our exports if something is defined for the requested controller type. Mark that the SingleOrDefault method is used because if more exports are defined for a controller, an exception will be throw. If this exception is thrown, something is wrong with the configuration of the CompositionContainer. If a single export is found, we’ll get the object from the Value property.

If the export isn’t found, the base method will be invoked. That way, the controller is created the default-way. When the controller is created, the ComposeParts method on the CompositionContainer is invoked. This will resolve the needed import for the controller.

This is the object that will be injected. The GetMessage method will return a string that will be shown on the view.

public interface IMyTest{
    String GetMessage();
}

[Export(typeof(IMyTest))]
public class MyTest1 : IMyTest{
    public MyTest1()
    {
        creationDate = DateTime.Now;
    }

    public string GetMessage()
    {
        return String.Format("MyTest1 created at {0}", creationDate.ToString("hh:mm:ss")) ;
    }

    private DateTime creationDate;
}

The Export attribute says to MEF that this class can be exported. The type of IMyTest is pasted as a parameter. This indicates the contract that is used. So when an IMyTest is requested from MEF, an object of MyTest1 is returned.

[Export]
public class HomeController : Controller{
    [Import]
    private IMyTest _myTest;

    public ActionResult Index()
    {
        ViewBag.Message = _myTest.GetMessage();

        return View();
    }
}

The HomeController is marked for export and an import attribute is put on the “_mytest” property. Of course we still need to configure MVC to use our MefControllerFactorty. To accomplish this, is created a static class with one static public method (RegisterMef). This method will create a Mef CompositionContainer and pass this container to the MefControllerFactory. This MefControllerFactory will be set as the controller factory for MVC. To configure the CompositionContainer an AssemblyCatalog is used.

public static class MefConfig{
    public static void RegisterMef()
    {
        var container = ConfigureContainer();

        ControllerBuilder.Current.SetControllerFactory(new MefControllerFactory(container));
        
        var dependencyResolver = System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver;
    }

    private static CompositionContainer ConfigureContainer()
    {
        var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
        var container = new CompositionContainer(assemblyCatalog);
        
        return container;
    }
}

The RegisterMef method will be called form the Application_Start method that resides in the global.asax.

public class MvcApplication : System.Web.HttpApplication{
     protected void Application_Start()
     {
        AreaRegistration.RegisterAllAreas();

        MefConfig.RegisterMef();

        WebApiConfig.Register(GlobalConfiguration.Configuration);
        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);
        AuthConfig.RegisterAuth();
     }
}

When the Index action for the HomeController is requested through the browser, everything works just fine but when it is requested it again, an exception is thrown.

A single instance of controller 'MvcApplication5.Controllers.HomeController' cannot be used to handle multiple requests. If a custom controller factory is in use, make sure that it creates a new instance of the controller for each request.

This exception is thrown because the lifetime of the controller is linked to the lifetime of the CompositionContainer. The container keeps a reference to all the objects that it has created. If the same object is requested, the reference of the previous object is given. There are 2 ways to solve this problem.

You could pass an instance of a ComposablePartCatalog (in this case the AssemblyCatalog) to the MefControllerFactorty. Then in the “GetControllerInstance” method always compose a new CompositionContainer to resolve the controller. Personally I'm not really found about that.

The other solution is to use a CreatonPolicy. If we put a CreationPolicy of “NonShared” on the HomeController, a new instance of the HomeController is created from scratch every time it gets requested. Since this a standard feature of MEF, I'll use this solution.

[Export]
[PartCreationPolicy(CreationPolicy.NonShared)]
public class HomeController : Controller{
    [Import]
    private IMyTest _myTest;

    public ActionResult Index()
    {
        ViewBag.Message = _myTest.GetMessage();

        return View();
    }
}

Now we can request the controller as many times as we want.

WebApi

This is the created WebApi controller. Mark that the controller also has a CreationPolicy defined. This is for the same reason a mentioned above.

[Export]
[PartCreationPolicy(CreationPolicy.NonShared)]
public class HomeController : ApiController{
    [Import]
    private IMyTest _myTest;

    public String GetMessage()
    {
        return _myTest.GetMessage();
    }
}

To plug in MEF in the WebApi a object needs to be created from the System.Web.Http.Dependencies.IDependencyResolver interface. This is how the object looks like.

public class MefDependencyResolver : IDependencyResolver{
    private readonly CompositionContainer _container;
    
    public MefDependencyResolver(CompositionContainer container)
    {
        _container = container;
    }

    public IDependencyScope BeginScope()
    {
        return this;
    }

    public object GetService(Type serviceType)
    {
        var export = _container.GetExports(serviceType, null, null).SingleOrDefault();

        return null != export ? export.Value : null;
    }

    public IEnumerable<object> GetServices(Type serviceType)
    {
        var exports =_container.GetExports(serviceType, null, null);
        var createdObjects = new List<object>();

        if ( exports.Any())
        {
            foreach (var export in exports)
            {
                createdObjects.Add(export.Value);
            }
        }

        return createdObjects;
    }

    public void Dispose()
    {
        ;
    }
}

The “BeginScope” method returns a scope in with the create objects will life. Since we are going to use MEF to control the lifetime of the created objects, we can do a return of “this”. We can do this because the IDependencyResolver inherits form IDependencyScope. If you really need a limited scope per request, the “BeginScope” method always needs to return a new object of type IDependencyScope.

You also need to implement a “Dispose” method to release the used resources. In the MefDependencyResolver, it isn’t implemented. This is because we return the current instance in the “BeginScope” method. If we disposed the CompositionContainer, we could only request the service once.

Right now, the only thing needed, is the register the create MefDependencyResolver. This will be done in the modified MefConfig class.

public static class MefConfig
   {
       public static void RegisterMef()
       {
           var container = ConfigureContainer();

           ControllerBuilder.Current.SetControllerFactory(new MefControllerFactory(container));
           
           var dependencyResolver = System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver;
           System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver = new MefDependencyResolver(container);
       }

       private static CompositionContainer ConfigureContainer()
       {
           var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
           var container = new CompositionContainer(assemblyCatalog);
           
           return container;
       }
   }

The example can be downloaded from here.

Entity Framework: Database Migrations

Tue, 14 Aug 2012 08:21:00 +0000

If you don’t like writing SQL DDL statement, like me, than Entity Framework is very handy. With the Code-First, you can write your model and don’t need to worry about your database. It is generated for you by Entity Framework. This is very handy but what if you are working with an existing database? Or if you need to support different versions of your database? That is where database migrations come in to play.

Before we start

Create an Asp.Net MVC 4 application
Use Nuget to install the latest version of the Entity Framework (5.0.0-rc)

Because i am not running an SQL Express or SQL Server on my machine, i am also going to install SqlServerCompact so i can work with an SDF file. This needs a little more configuration.

Install EntityFramework.SqlServerCompact form Nuget.
Change the connectionstring in the web.config
<connectionStrings>
<add name="DefaultConnection" connectionString="Data Source=|DataDirectory|\DBTest.sdf;Max Database Size=2047" providerName="System.Data.SqlServerCe.4.0" />
</connectionStrings>

Create your models. In my case i will create as Car and Make class.

namespace EF_DatabaseMigrations.Models
{
    public class Car
    {
        public Int32 Id { get; set; }

        public String Model { get; set; }

        public Make Make { get; set; }
    }

    public class Make
    {
        public Int32 Id { get; set; }

        public String Name { get; set; }
    }
}

Next i will create a DbDatasource that will map my entities to the database. This datasource will pass the name of the connectionstring to the base constructor.

namespace EF_DatabaseMigrations.DB
{
    public class DbDatasource : DbContext
    {
        public DbDatasource()
            : base("DefaultConnection")
        { }

        public DbSet<Car> Cars { get; set; }

        public DbSet<Make> Makes { get; set; }
    }
}

Let’s migrate

To configure your application to use migrations, you have to type “enable-migrations” command in the Package Manager Console. This will create a Migrations folder that contains a Configuration file. This class contains a seed method that accepts the DbDatasource as a parameter. The seed method will always be execute when you update your database. This method will typically be used to create users in the database or in our case to create the Makes in our database. By default, AutomaticMigrationsEnabled will be set to false. Since we want to automate everything, we need to set it to true :-).

namespace EF_DatabaseMigrations.Migrations
{
    internal sealed class Configuration : DbMigrationsConfiguration<EF_DatabaseMigrations.DB.DbDatasource>
    {
        public Configuration()
        {
            AutomaticMigrationsEnabled = true;
        }

        protected override void Seed(EF_DatabaseMigrations.DB.DbDatasource context)
        {
            context.Makes.AddOrUpdate(m => m.Name, new Make { Name = "Ford" }
                                                 , new Make { Name = "Opel" }
                                                 , new Make { Name = "BMW" });
        }
    }
}

Because the Seed method is always called, we have to make sure that the Makes we are adding, only are getting inserted if they don’t exists or are updated when they do exists the database. That is why we are using the AddOrUpdate methode. The first parameter is in fact our condition for the insert or update. If a make with a name “Ford” doesn’t exists in the database, it is inserted. If it does exists, it gets updated.

When we type “update-database” command in the Package Manager Console, EF will create our database and will call the Seed method. The location of the database will be determined by the connectionstring that you specify. In our case it will be found in the App_Data folder.

When we open the database, we see that a Cars and a Makes table are created. The Makes table is pre-filled.

In the table “_MigrationHistory” all migrations that where performed on this database are stored. That way you can always see what version of database this is. Also Entity Framework will need this information.

Now let’s assume that we want to add a BuildDate property to the Car. We can put this in a new migration. This way we can keep track of all our modifications in our database.

Change the Car entity.

public class Car
{
    public Int32 Id { get; set; }

    public String Model { get; set; }

    public Make Make { get; set; }

    public DateTime BuildDate { get; set; }
}

Add Migration

Type “add-migration AddBuildDate” in the Package Manager Console. This will create a new file in the Migration folder. The file name will contain the date + the name that we specified.

This new file will contain 2 methods that we can override. The “Up” method will contain all new database modifications. The “Down” will contain the rollback of the modifications. This way we can easily “jump” through database versions. We manually add the AddColumn and DropColumn statements.

namespace EF_DatabaseMigrations.Migrations
{
    public partial class AddBuildDate : DbMigration
    {
        public override void Up()
        {
            AddColumn("dbo.Cars", "BuildDate", c => c.DateTime(nullable: false));
        }

        public override void Down()
        {
            DropColumn("dbo.Cars", "BuildDate");
        }
    }
}

When we want to apply those modifications, we need to type “update-database -TargetMigration:AddBuildDate”. This will modify our database and add the new column.

If you want to rollback the database at it’s begin state, you type “update-database -TargetMigration:0” in the Package Console Manager.

What about the database adminstrators

We can’t forget these guys. They probably won’t like this way of creating the database and would probably prefer a script. Well you can add an extra parameter to the “update-database” called script that will create a clean SQL script that performs all the necessary steps to create the database.

“update-database –TargetMigration:AddBuildDate –script” will create this script:

ALTER TABLE [Cars] ADD [BuildDate] [datetime]
INSERT INTO [__MigrationHistory] ([MigrationId], [Model], [ProductVersion]) VALUES ('201208140904052_AddBuildDate', 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rc.net40')

The Visual Studio solution can be downloaded here.

ASP.NET MVC: Set Focus, ViewModel Style

Wed, 16 May 2012 15:58:00 +0000

In a recent Asp.Net MVC project i had to set a focus on a specific control, but it wasn’t just a specific control. It was calculate in runtime by some conditions. I didn’t just want to create an extra string property on the viewmodel where i could store the id of the control. Off course this would also work but i wanted something safer than those magic strings.

In one of my previous posts [Where is the ClientID?](http://blog.kennytordeur.be/post/2011/05/10/aspnet-mvc-where-is-the-clientid), i was able to determine the Id that is created by the HtmlHelper to create a textbox, checkbox, …

public static class HtmlHelper
{
    public static String GetId<TModel,TProperty>( this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression )
    {
        return TagBuilder.CreateSanitizedId(ExpressionHelper.GetExpressionText(expression));
    }
}

So i created a property called Focus on my ViewModelBase class with the exacte same type, but for the return type of the function i take Object.

public abstract class ViewModelBase<T>
   {
       public Expression<Func<T,Object>>  Focus { get; set; }
   }

Then my PersonViewModel inherits from ViewModelBase<T> where T equals the PersonViewModel type. That way i have complete intellisence when i want to set the Focus property.

public class PersonViewModel : ViewModelBase<PersonViewModel>
    {
        public String Name { get; set; }

        public String LastName { get; set; }
    }

At the view side, i’ll use the GetId extension method to determine the id off the control i want to set the focus to. I’ll pas the Focus property as parameter for this extension method. Then i’ll use it’s result in a JQuery selector and invoke the .focus() method.

@model ASP.NET_MVC_Set_Focus_ViewModel_Style.Models.PersonViewModel
@{
    ViewBag.Title = "Index";
}
<h2>
    Index</h2>
@using (Html.BeginForm())
{
    <table>
        <tr>
            <td>
                Name
            </td>
            <td>
                @Html.TextBoxFor(m => m.Name)
            </td>
        </tr>
        <tr>
            <td>
                Lastname
            </td>
            <td>
                @Html.TextBoxFor(m => m.LastName)
            </td>
        </tr>
    </table>
    @Html.HiddenFor(m => m.Focus)
    <input type="submit" value="ChangeFocus" />
}
<script type="text/javascript">
    $(document).ready(function () {
        $("#@Html.GetId(Model.Focus)").focus();
    });
</script>

At the Controller side, on the HttpGet method, i’ll set the focus on the Name. On the HttpPost method, i’ll set the focus on LastName. That way you’ll see the difference.

public class HomeController : Controller
    {
        [HttpGet]
        public ActionResult Index()
        {
            var personViewModel = new PersonViewModel();

            personViewModel.Focus = m => m.Name;

            return View(personViewModel);
        }

        [HttpPost]
        public ActionResult Index(PersonViewModel personViewModel)
        {
            personViewModel.Focus = m => m.LastName;

            return View(personViewModel);
        }
    }

The main advantage is that you don’t have to work with those magic strings. When the property is renamed or removed, i’ll get a compiler error. And your code is cleaner.

This code isn’t rocket science but can be very handy. The solution can be downloaded from here.

ASP .NET MVC and Unity: Navigating through Interfaces

Sat, 10 Sep 2011 08:55:00 +0000

In this previous [post](http://blog.kennytordeur.be/post/2011/05/03/aspnet-mvc-3-and-unity-using-an-idependencyresolver) you saw how i used an IDependencyResolver in combination with an IUnityContainer to created a loosely coupled application. But there is still one dependency that i want to cut and that is the url that is used to navigate.

Normally if we want to navigate to the Index action of our HomeController we use something like this in the url: http://localhost/Home/Index
That is an dependency that i want to cut, because we ask to use a controller of type “HomeController”
.
What i want to do is to navigate through interfaces, http://localhost/IHome/Index for example. When we type this, it will be up to Unity to resolve the requested controller. I will use the solution used in this [post](http://blog.kennytordeur.be/post/2011/05/03/aspnet-mvc-3-and-unity-using-an-idependencyresolver) as base.

Let’s get started

The first thing that we need to do is to create an IHomeController interface. This interface will be implemented by our HomeController.

IHomeController interface
using System.Web.Mvc;
 namespace MVCWebsite.Controllers
 {
     public interface IHomeController: IController
     {
         System.Web.Mvc.ActionResult Index();
     }  
 }

HomeController
using System.Web.Mvc;
 using MVCWebsite.Repository;
 
 namespace MVCWebsite.Controllers
 {
     public class HomeController: Controller, MVCWebsite.Controllers.IHomeController
     {
         ITitleRepository titleRepository = null;
 
         public HomeController(ITitleRepository titleRepository)
         {
             titleRepository = titleRepository;
         }
 
                 
         public ActionResult Index()
         {
             ViewBag.Title = titleRepository.GetTitle("Index");
 
             return View();
         }             
     }
 }

Now that we created an interface, we will register it with our Unitycontainer. This mains i will have to adapt my UnityConfigurator class.

UnityConfigurator

using System.Web.Mvc;
using Microsoft.Practices.Unity;
using MVCWebsite.Controllers;
using MVCWebsite.IoC;
using MVCWebsite.Repository;

namespace MVCWebsite.Ioc
{
    public class UnityConfigurator
    {
        public static IUnityContainer GetContainer()
        {
            IUnityContainer container = new UnityContainer();

            container.RegisterType<IControllerFactory, UnityControllerFactory>();
            container.RegisterType<IHomeController, HomeController>();
            container.RegisterType<ITitleRepository, TitleRepository2>(new HttpContextLifetimeManager<ITitleRepository>());

            return container;
        }
    }
}

When we type an url in our browser the ControllerFactory is used to return an instance of the requested controller. We already use a custom ControllerFactory ( UnityControllerFactory ) so we’ll need to change it’s implementation a bit.

You can override a couple of methods of a ControllerFactory. But we are only interested in 2 of them:

GetControllerType(System.Web.Routing.RequestContext requestContext, string controllerName)

IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType)

The GetControllerType is actually responsible for converting the controllername, that is typed in an url, to a specific type. So we will have to override this method so that we can write our custom logic.

UnityControllerFactory

protected override Type GetControllerType(System.Web.Routing.RequestContext requestContext, string controllerName)
        {
            // use the base method
            Type type = base.GetControllerType(requestContext, controllerName);

            // If the base method can't resolve a controllername, we 'll have to help it a hand.
            if (null == type)
            {
                Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
                foreach (var assembly in assemblies)
                {
                    type = assembly.GetTypes().SingleOrDefault(t => t.Name == String.Format("{0}Controller", controllerName));
                    if (null != type)
                        break;
                }
            }

            return type;
        }

If the base method can’t resolve the requested controller type, we’ll look in the current loaded assemblies to see if we can find the type of the requested controller. I still use the base method so that the default way of navigation still works. If you completely want to navigate through interfaces, you don’t make a call to it’s base method. So when we type /IHome/Index, this method will return IHomeController as type.

Now that we have the requested controller type, we’ll need to create an instance of that controller. That’s why we’ll need to override the GetControllerInstance of our ControllerFactory ( UnityControllerFactory ).

The current DependecyResolver will be used create the requested controller. Remember that the current DependencyResolver is our UnityDependencyResolver and that it will use Unity to create an instance of the requested controller type. When we have an instance of the controller, we’ll just need to change the “controller” value in the routedata. If we don’t to this, MVC will try to resolve the requested view in the IHome folder, instead of the Home folder.

UnityControllerFactory

protected override IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType)
        {
            IController result = null;

            if (null != controllerType)
            {
                // resolve the requested controller type through the DependencyResolver
                result = DependencyResolver.Current.GetService(controllerType) as IController;

                if (result != null)
                {
                    // change the route data so that we'll look in the right place to resolve the requested view
                    requestContext.RouteData.Values["controller"] = result.GetType().Name.Replace("Controller", "");
                }
            }

            return result;
        }

Let’s test it

So when we type /IHome/Index, we’ll get the index page of the HomeController.

<img style="background-image: none; padding-left: 0px; padding-right: 0px; display: inline; padding-top: 0px; border-width: 0px;" title="image" src="http://lh4.ggpht.com/-EOAeyxvkhw/TmtCEd3zr5I/AAAAAAAAAFI/2Lizr5dVLEc/imagethumb.png?imgmax=800" alt="image" width="680" height="174" border="0" />

Let’s go a step further

It’s common for applications that for certain users you need to display a different page with more/less functionality. Let’s assume that users who are in the role ”Admin” needs to see a different page as their home page. Since we removed the dependency between the url and controller we can easily achieve this functionality.

We create a controller called '”AdminHomeController” which will implement the IHomeController interface. We also create an Index view for the AdminHomeController.

AdminHomeController
using System.Web.Mvc;
 using MVCWebsite.Repository;
 
 namespace MVCWebsite.Controllers
 {
     public class AdminHomeController : Controller, MVCWebsite.Controllers.IHomeController
     {
         ITitleRepository _titleRepository = null;
 
         public AdminHomeController(ITitleRepository titleRepository)
         {
             titleRepository = titleRepository;
         }
 
         //
         // GET: /Home/
         public ActionResult Index()
         {
             ViewBag.Title = titleRepository.GetTitle("Index");
 
             return View();
         }       
     }
 }

Now we have to change our UnityConfigurator a little. In Unity is possible to create an “InjectionFactory”. You can link a function with an Injectionfactory. This means that the function will be responsible to return an instance of the requested type.

We’ll create an InjectionFactory for the IHomeController type. This injectionfactory will return an AdminHomeController for users who have an “Admin” role, for all other users a HomeController will be returned.

UnityConfigurator

using System.Web;
using System.Web.Mvc;
using Microsoft.Practices.Unity;
using MVCWebsite.Controllers;
using MVCWebsite.IoC;
using MVCWebsite.Repository;

namespace MVCWebsite.Ioc
{
    public class UnityConfigurator
    {
        public static IUnityContainer GetContainer()
        {
            IUnityContainer container = new UnityContainer();

            container.RegisterType<IControllerFactory, UnityControllerFactory>();

            container.RegisterType<IHomeController>(new InjectionFactory(c =>
                                                                {
                                                                    if (HttpContext.Current.User.IsInRole("Admin"))
                                                                    {
                                                                        return (c.Resolve<AdminHomeController>());
                                                                    }
                                                                    else
                                                                    {
                                                                        return (c.Resolve<HomeController>());
                                                                    }
                                                                }));

            container.RegisterType<ITitleRepository, TitleRepository2>(new HttpContextLifetimeManager<ITitleRepository>());

            return container;
        }
    }
}

When a user who is in the “Admin” role types /IHome/Index as url, an instance of AdminHomeController will be returned and he’ll see the Index view from the AdminHome folder.

<a href="http://lh3.ggpht.com/-t8XLO6u1CJY/TmtCFM3jE2I/AAAAAAAAAFM/DssiWTQgLw/s1600-h/image11.png">

Hope you enjoyed reading it. The solution can be downloaded here.

ASP.NET MVC: Where is the ClientID?

Tue, 10 May 2011 14:36:00 +0000

For those who are used to program in ASP.NET know this scenario. You have a textbox and you want to do some custom validation in Javascript. You have to be able to access the textbox from the Javascript. The first thing you need to know is the Id for that textbox. You can't hard code it, because you are not sure how ASP.NET will generate the Id. If the control exists in an INamingContainer, the INamingContainer will add some prefix to the Id of the control.

That is where the ClientID property comes to the rescue. This property contains the Id that will be used in HTML. Take a look at this example.

<%@ Page Title="Home Page" Language="C#" MasterPageFile="~/Site.master" AutoEventWireup="true"
    CodeBehind="Default.aspx.cs" Inherits="WebApplication1._Default" %>

<asp:Content ID="HeaderContent" runat="server" ContentPlaceHolderID="HeadContent">
</asp:Content>
<asp:Content ID="BodyContent" runat="server" ContentPlaceHolderID="MainContent">

    <script type="text/javascript" language="javascript">
        function ButtonClicked() {
            var element = document.getElementById('<%= MyTextBox.ClientID %>');
            alert('Value: ' + element.id);
        }
    </script>

   <asp:TextBox ID="MyTextBox" runat="server" />
   <button onclick="javascript:ButtonClicked()">Click Here</button>
</asp:Content>

In this example the Id of MyTextBox will be showed in a messagebox. Because MyTextBox is added in a Asp:Content control, the Id of this textbox will be prefixed with something. When we run the site and look at the source of the webpage, we will see it's id.

<script type="text/javascript" language="javascript">
        function ButtonClicked() {
            var element = document.getElementById('MainContentMyTextBox');
            alert('Value: ' + element.id);
            }    
</script>   
   <input name="ctl00$MainContent$MyTextBox" type="text" value="dfd" id="MainContentMyTextBox" />
   <button onclick="javascript:ButtonClicked()">Click Here</button>

But how do we do this in ASP.NET MVC?

Take a look at this example. We use the TextBoxFor extension method to generate a textbox for our model. How do we figure out the Id that is used for the textbox?

@model MvcApplication2.Models.Person
@{
    ViewBag.Title = "Home Page";
}

<h2>@ViewBag.Message</h2>
<p>
   <script type="text/javascript" language="javascript">
       function ButtonClicked() {
           var element = document.getElementById("????");
           alert("Value: ??");
           }
   </script>

   @Html.TextBoxFor(m => m.Name);
   <button onclick="javascript:ButtonClicked()">Click Here</button>
</p>

You can hardcode the Id of the textbox ( "Name" ) in the javascript, but would it not be a lot more beautiful or easier ( intellisense) if you could pas a lambda expression?

After looking in Reflector i saw that MVC uses this static class for generating an Id and it passes this Id to a static method of the TagBuilder class called "CreateSanitizedId".

Now that we know this, the only thing left to do is to create an HtmlHelper extension that will do exactly the same.

namespace System.Web.Mvc.Html
{
    public static class IdHtmlHelper
    {
        public static String GetIdFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
        {
            return TagBuilder.CreateSanitizedId(ExpressionHelper.GetExpressionText(expression));
        }
    }
}

Now we can write our code like this:

@model MvcApplication2.Models.Person
@{
    ViewBag.Title = "Home Page";
  }

<h2>@ViewBag.Message</h2>
<p>
   <script type="text/javascript" language="javascript">
       function ButtonClicked() {
           var element = document.getElementById("@Html.GetIdFor( m=> m.Name)");
           alert("Value: " + element.id);        
       }
   </script>

  @Html.TextBoxFor( m => m.Name)
  <button onclick="javascript:ButtonClicked()">Click Here</button>
</p>

When we render the page and look at the source, we can see that the Id is put in the getElementById method.

<p>
   <script type="text/javascript" language="javascript">
       function ButtonClicked() {
           var element = document.getElementById("Name");
           alert("Value: " + element.id);        
       }
   </script>
   <input id="Name" name="Name" type="text" value="John Doe" />
   <button onclick="javascript:ButtonClicked()">Click Here</button>
</p>

ASP.NET MVC 3 and Unity using an IDependencyResolver

Tue, 03 May 2011 14:08:00 +0000

In this post i used a custom ControllerFactory for dependency injection. I created a custom ControllerFactory where i overrided the GetControllerInstance method. In this method i used the UnityContainer for creating instances of the requested controller.

In ASP.NET MVC 3 their is some build in abstraction for doing dependency injection (IDependencyResolver). I will change the example used in this post to use the IDependencyResolver.

The IDependencyResolver

The IDependencyResolver is a fairly easy interface. It contains only 2 methods:

In our case, we will create an UnityDependencyResolver. This implementation will accept an IUnityContainer and will use this container for resolving the requested types. If the DependencyResolver is unable to resolve a type, it should always return null for the GetService method and an empty collection for the GetServices method. That is why a try catch is used in the UnityDependencyResolver.

    public class UnityDependencyResolver : IDependencyResolver
    {
        IUnityContainer container = null;

        public UnityDependencyResolver(IUnityContainer container)
        {
            this.container = container;
        }

        #region IDependencyResolver Members

        public object GetService(Type serviceType)
        {
            try
            {
                return container.Resolve(serviceType);
            }
            catch
            {
                return null;
            }
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            try
            {
                return container.ResolveAll(serviceType);
            }
            catch
            {
                return new List<object>();
            }
        }

        #endregion
    }

Registering the UnityDependencyResolver

Now that we created this dependency resolver, we have to register it so that the MVC framework will use it. This is done in the Global.asax, in the Application_Start method.

  protected void ApplicationStart()
  {
      AreaRegistration.RegisterAllAreas();

      RegisterGlobalFilters(GlobalFilters.Filters);
      RegisterRoutes(RouteTable.Routes);

      DependencyResolver.SetResolver(new UnityDependencyResolver(UnityConfigurator.GetContainer()));
  }

You could also register it inside a WebActivator.PreApplicationStartMethod.

Changing the UnityControllerFactory

In the UnityControllerFactory we now can use the IDependencyResolver that we registered to resolve the requested controllers. It doesn't need to work with an IUnityContainer any more.

    public class UnityControllerFactory : DefaultControllerFactory
    {        
        protected override IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType)
        {
            IController result = null;

            if (null != controllerType)
            {
                result = DependencyResolver.Current.GetService(controllerType) as IController;
            }

            return result;
        }
    }

Changing the UnityConfigurator

As you might have noticed the Application_Start method of the Global.asax has changed a bit. The line for registering our UnityControllerFactory has been removed (see this). The MVC 3 framework will use it's current DependencyResolver to resolve a ControllerFactory, so we have to register our UnityControllerFactory with the IUnityContainer. Now the MVC 3 framework will use our UnityControllerFactory as it's default ControllerFactory.

public class UnityConfigurator
{
    public static IUnityContainer GetContainer()
    {
        IUnityContainer container = new UnityContainer();

        container.RegisterType<IControllerFactory, UnityControllerFactory>();
        container.RegisterType<ITitleRepository, TitleRepository2>(new HttpContextLifetimeManager<ITitleRepository>());

        return container;
    }
}

ASP.NET MVC and Unity

Sat, 23 Apr 2011 07:40:00 +0000

What is Unity?

The Unity Application Block (Unity) is a lightweight extensible dependency injection container with support for constructor, property, and method call injection. Dependency injection is used to create loosely coupled applications. These kind of applications are easier to maintain and easier to test.

What do we want to achieve?

We want to make our controllers loosely coupled and break any hard dependencies it has. Every object/resource that our controller needs, has to be automatically populated and correctly initiated by Unity.

The Asp.net mvc application

This is the HomeController that we have in our application.

public class HomeController : Controller
{
    ITitleRepository _titleRepository = null;

    public HomeController()
    {
        _titleRepository = new TitleRepository();
    }

    //
    // GET: /Home/
    public ActionResult Index()
    {
        ViewBag.Title = _titleRepository.GetTitle("Index");

        return View();
    }
}

As you can see, it uses a TitleRepository. This repository is used to determine which title has to be rendered on a specific page.

titleRepository = new TitleRepository();

This is the line that we want to remove. With this, we make a hard dependency between our HomeController and the TitleRepository.

    public interface ITitleRepository
    {
        string GetTitle(String page);
    }

    public class TitleRepository : MVCWebsite.Repository.ITitleRepository
    {
        public String GetTitle(String page)
        {
            return String.Format(" This is a Title for the page: {0}", page);
        }
    }

Using Unity

Adding references

Add the Microsoft.Practices.Unity dll to you project. Unity can be found at http://unity.codeplex.com/.

Creating a custom LifetimeManager

When you register a type with Unity, you can also specify a lifetime of this type. If you don't specify a lifetime, Unity will create a new instance of that type each time that the type is requested. In an Asp.Net application, we can make the LifetimeManager cache or store the created objects in the HttpContext HttpSession or HttpApplication. In my case, i want a singleton per request.

    public class HttpContextLifetimeManager<T> : LifetimeManager
    {
        public override void SetValue(object newValue)
        {
            HttpContext.Current.Items[typeof(T).AssemblyQualifiedName] = newValue;
        }

        public override object GetValue()
        {
            return HttpContext.Current.Items[typeof(T).AssemblyQualifiedName];
        }

        public override void RemoveValue()
        {
            HttpContext.Current.Items.Remove(typeof(T).AssemblyQualifiedName);
        }  
    }

Creating the UnityContainer

Next in line is the creation of a UnityContainer. This container will be used to resolve certain types. In order to work, we have to register these types. In our case, we our going to register the ITitleRepository type with the TitleRepository type. This will mean that if we ask the container to resolve the ITitleRepository, it will return a TitleRepository object. As you see, i pass the HttpContextLifetimeManager as parameter.

public class UnityConfigurator
{
    public static IUnityContainer GetContainer()
    {
        IUnityContainer container = new UnityContainer();

        container.RegisterType<ITitleRepository, TitleRepository>(new HttpContextLifetimeManager<ITitleRepository>());

        return container;
    }
}

Now we are registering our type hardcoded. It is also possible doing this in the config file.

Creating a Controller Factory

We need to create a custom Controller factory to replace the default factory that is used by the MVC framework. Our factory accepts a IUnityContainer as parameter. This container contains all the types we registered.

We only need to override the GetControllerInstance method. In this method we have to use the container to create an instance of the requested controller. This way, Unity will automatically resolve the requested types for this controller. In our case: ITitleRepository.

    public class UnityControllerFactory : DefaultControllerFactory
    {
        IUnityContainer container = null;

        public UnityControllerFactory(IUnityContainer container)
        {
            this.container = container;
        }

        protected override IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType)
        {
            IController result = null;

            if (null != controllerType)
            {
                result = container.Resolve(controllerType) as IController;
            }

            return result;
        }
    }

Now we have to tell the MVC framework to use the UnityControllerFactory as it's default controller factory. This is done best in the global.asax, in the Application_Start method.

protected void ApplicationStart()
{
    AreaRegistration.RegisterAllAreas();

    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);
    ControllerBuilder.Current.SetControllerFactory(new UnityControllerFactory(UnityConfigurator.GetContainer()));
}

Breaking the dependency

Now we have to modify our HomeController. We change it's constructor to accept an object of the ITitleRepository type.

    public class HomeController : Controller
    {
        ITitleRepository _titleRepository = null;

        public HomeController(ITitleRepository titleRepository)
        {
            titleRepository = titleRepository;
        }

        //
        // GET: /Home/
        public ActionResult Index()
        {
            ViewBag.Title = titleRepository.GetTitle("Index");

            return View();
        }
    }

The result

When we go to the index of the HomeController, our UnityControllerFactory comes in action and Untity will inject the TitleRepository in the constructor of the HomeController.

When i want to use another implementation of the ITitleRepository, i only have to change the GetContainer method of the UnityConfigurator and the HomeController will automatically be injected with the new implementation.

public class TitleRepository2 : MVCWebsite.Repository.ITitleRepository
{
    public string GetTitle(String page)
    {
        return String.Format("{0} is the Title for this page!", page.ToUpper());
    }
}

public class UnityConfigurator
{
    public static IUnityContainer GetContainer()
    {
        IUnityContainer container = new UnityContainer();

        container.RegisterType<ITitleRepository, TitleRepository2>(new HttpContextLifetimeManager<ITitleRepository>());

        return container;
    }
}

NHibernate in combination with a webservice

Thu, 07 Apr 2011 04:38:00 +0000

In this post i'ill try to explain how you can make NHibernate interact with a webservice to fill in a certain object.

Current situation

This is the current situation that we have.

We have a webservice called "Marial State service". This service is responsible for all marial states available. This service has only 2 methods:

GetAll()
- Gives all the available marial states
GetById(Int32 id)
- Gives a specific marial state by it's id

The client is an application that has it's own database and uses NHibernate as ORM. The client is responsible for creating/updating/deleting persons in his database. So in the database we find a table called "Person" with contains all the data.

As you can see, the person, has a marial state which comes from the MarialState service. For those who noticed, yes i am using an Access as database. Here you can find the needed DLL.

The MarialState service

I created 2 new projects in visual studio. One which contains the model off the service.

namespace NHibernateWebservices.WebServiceProxy.Model
{
    public class MarialState
    {
        public Int32 Id { get; set; }
        public String Description { get; set; }
    }
}

And another project for the service logic. As you can see this isn't a real service. I am mocking it.

namespace NHibernateWebservices.WebServiceProxy
{
    public static class MarialState
    {
        public static List<Model.MarialState> GetAll()
        {
            return new List<Model.MarialState>
                                {
                                    new Model.MarialState { Id = 1, Description = "Single"}
                                    ,new Model.MarialState { Id = 2, Description = "Married"}
                                    ,new Model.MarialState { Id = 3, Description = "widower"}
                                };
        }
        public static Model.MarialState GetById(Int32 id)
        {
            return GetAll().SingleOrDefault(m => m.Id == id);
        }
    }
}

The client

At client side the we created a business object called "Person" which will map at the Person table in it's database.

public class Person
{
    public virtual Int32 Id { get; set; }
    public virtual String FullName { get; set; }
    public virtual Int32 MarialStateId { get; set; }
}

This is the mapping file for the "Person" entity.

<?xmlversion="1.0" ?>
<hibernate-mappingxmlns="urn:nhibernate-mapping-2.2">
    <classname="NHibernateWebservices.Model.Person, NHibernateWebservices.Model"
         table="Person">
    <idname="Id"
        column="Id"
              unsaved-value="0">
      <generatorclass="increment" />
    </id>

    <propertycolumn="FullName"
              name="FullName"
              type="String" />

    <propertyname="MarialStateId"
             column="MarialStateId"
             type="int"/>

  </class>
</hibernate-mapping>

Now How to get the data?

First try

The most easy way to get the MarialState entity would be to write something like this.

public class Person
{
    public virtual Int32 Id { get; set; }
    public virtual String FullName { get; set; }      

    private Int32 marialStateId;
    public virtual Int32 MarialStateId
    {
        get
        {
            return marialStateId;
        }
        set
        {
            marialStateId = value;
        }
    }

    public virtual WebServiceProxy.Model.MarialState MarialState
    {
        get
        {
            return WebServiceProxy.MarialState.GetById(marialStateId);
        }
        set
        {
            marialStateId = (null == value) ? (0) : (value.Id);
        }
    }
}

This solution will work, but I can see several things that I am not happy with. First of all it's a lot off extra code. In this case the "Person" entity is very simple, but what if it was complex and you needed to get other data from a service, you would be writing a lot of code looking like this.

Second

In this approach you need to create a reference between the WebServiceProxy and the business Model of the client. At this point the business Model of the client is also responsible to fill it's own data instead of only validating against business rules.

Using NHibernate IUserType

The ideal situation would that we ask NHibernate to give use a "Person" and that everything, including MarialState object, would be filled automatically. You can do this if you create a new NHibernate IUserType object. IUserType is an interface which allows you to plug in into the NHibernate mapping process and handle it your self.

public class MarialStateUserType : IUserType
{
    public object Assemble(object cached, object owner)
    {
        return DeepCopy(cached);
    }

    public object DeepCopy(object value)
    {
        return value;
    }

    public object Disassemble(object value)
    {
        return DeepCopy(value);
    }

    public int GetHashCode(object x)
    {
        return x.GetHashCode();
    }

    public bool IsMutable
    {
        get { return true; }
    }

    public object NullSafeGet(System.Data.IDataReader rs, string[] names, object owner)
    {
        object obj = NHibernateUtil.Int32.NullSafeGet(rs, names[0]);
        WebServiceProxy.Model.MarialState marialState = null;

        if (null != obj)
        {
            marialState = WebServiceProxy.MarialState.GetById(Convert.ToInt32(obj));
        }

        return marialState;
    }

    public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index)
    {
        WebServiceProxy.Model.MarialState marialState = value as WebServiceProxy.Model.MarialState;

        var parameter = (IDataParameter)cmd.Parameters[index];
        if (null == marialState)
            parameter.Value = DBNull.Value;
        else
            parameter.Value = marialState.Id;
    }

    public Type ReturnedType
    {
        get { return typeof(WebServiceProxy.Model.MarialState); }
    }

    public SqlType[] SqlTypes
    {
        get { return new SqlType[] { NHibernateUtil.Int32.SqlType }; }
    }

    public object Replace(object original, object target, object owner)
    {
        return original;
    }

    public new bool Equals(object x, object y)
    {
        if (object.ReferenceEquals(x, y)) return true;
        if (x == null || y == null) return false;
        return x.Equals(y);
    }
}

This it the custom IUsertype that is created for the MarialState entity. In this example, these are the most interesting parts of code:

ReturnedType
SqlTypes
NullSafeGet
NullSafeSet

ReturnedType/SqlTypes properties

The ReturnedType and SqlTypes properties tells NHibernate which type to expect. The ReturnedType property contains the type of object that this IUsertype has to return. In our case it is a MarialState object.

public Type ReturnedType
{
    get { return typeof(WebServiceProxy.Model.MarialState); }
}

The SqlTypes property tells how the object is mapped in the database. Here the MarialState object is mapped to a numerical column.

public SqlType[] SqlTypes
{
    get { return new SqlType[] { NHibernateUtil.Int32.SqlType }; }
}

NullSafeGet/NullSafeSet methods

The NullSafeSet method is called when we want to save/update our object. In our case, the parameter "value" will contain our MarialState entity. The parameter "cmd" will contain the command that is used to update/insert the "Person" entity in the database.

What we now have to do, is to insert the Id of the MarialState entity in the command at the index place. We know the index because it is passed to the NullSafeSet method. If the MarialState entity is empty, we insert the DBNull value.

public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index)
{
    WebServiceProxy.Model.MarialState marialState = value as WebServiceProxy.Model.MarialState;

    var parameter = (IDataParameter)cmd.Parameters[index];
    if (null == marialState)
        parameter.Value = DBNull.Value;
    else
        parameter.Value = marialState.Id;
}

The NullSafeSet method is called when we want to extract the data from the database. This method will return a MarialState entity. As you can see, this method has a IDataReader object as parameter. From this IDataReader we have to extract the MarialStateId column and use it's value to get the MarialState entity from the MarialState service. We also do a check to see if the value isn't null because it could be NULL in the database.

public object NullSafeGet(System.Data.IDataReader rs, string[] names, object owner)
{
    object obj = NHibernateUtil.Int32.NullSafeGet(rs, names[0]);
    WebServiceProxy.Model.MarialState marialState = null;

    if (null != obj)
    {
        marialState = WebServiceProxy.MarialState.GetById(Convert.ToInt32(obj));
    }

    return marialState;
}

Putting the pieces together

Now that everything is in place, we can start to glue it together. First of all, we can change the "Person" entity at the client. The property MarialStateId can now be replaced by the MarialState property. The class looks a lot cleaner this way.

public class Person
{
    public virtual Int32 Id { get; set; }
    public virtual String FullName { get; set; }

    public virtual WebServiceProxy.Model.MarialState MarialState { get; set; }
}

Next in line is to change the mapping file for the "Person" entity. In this file we are going to make use of the MarialStateUserType that we created.

<?xmlversion="1.0" ?>
<hibernate-mappingxmlns="urn:nhibernate-mapping-2.2">
    <classname="NHibernateWebservices.Model.Person, NHibernateWebservices.Model"
         table="Person">
    <idname="Id"
        column="Id"
              unsaved-value="0">
      <generatorclass="increment" />
    </id>

    <propertycolumn="FullName"
              name="FullName"
              type="String" />

    <propertyname="MarialState"
              column="MarialStateId"
              type="NHibernateWebservices.NHibernateUserType.MarialStateUserType, NHibernateWebservices"/>

  </class>
</hibernate-mapping>

If we run the client and get a "Person" from the database, the MarialState will be filled automatically be NHibernate.

What about the performance?

If you have some performance problems, you can always but lazy loading on the MarialState property. This way we will only go to the service if we use the MarialState property.

<propertyname="MarialState"
          column="MarialStateId"
          lazy="true"
          type="NHibernateWebservices.NHibernateUserType.MarialStateUserType, NHibernateWebservices"/>

WCF KnownType

Thu, 24 Mar 2011 05:14:00 +0000

In object-oriented programming the concept of polymorphism is frequently used. This can cause problems in a WCF service if no action is taken. This is where KnownType comes to the rescue.

This is the WCF service that we are going to use in this example.

    [ServiceContract(
        Namespace="http://localhost/WeatherForeCast"
        ,Name="WeatherForeCastService")]
    public interface IWeatherForeCastService
    {
        [OperationContract]
        WeatherForeCast GetWeatherForeCast(DateTime day);
    }
    public class WeatherForeCastService : IWeatherForeCastService
    {
        public WeatherForeCast GetWeatherForeCast(DateTime day)
        {
            return new WeatherForeCast { Celsius = 30, Day = day };
        }
    }

This service has only 1 method. The GetWeatherForeCast method gives us a weather forecast for a specific day ( = parameter ).

This is how the WeatherForeCast object looks like.

    [DataContract]
    public class WeatherForeCast
    {
        [DataMember]
        public int Celsius { get; set; }

        [DataMember]
        public DateTime Day { get; set; }
    }

Fore some reason, the service method must also return Farenheit as property on all the uneven days. So we decide to create a new class WeatherForeCastExtra that inherits from WeatherForeCast and add the extra property.

    [DataContract]
    public class WeatherForeCastExtra: WeatherForeCast
    {        
        [DataMember]
        public int Farenheit { get; set; }
    }

Off course we also have to modify our service so that it could return a WeatherForeCastExtra object on all the uneven days.

    public class WeatherForeCastService : IWeatherForeCastService
    {
        public WeatherForeCast GetWeatherForeCast(DateTime day)
        {
            if ((day.Day % 2) == 0)
            {
                return new WeatherForeCast { Celsius = 30, Day = day };
            }
            else
            { 
                return new WeatherForeCastExtra { Celsius = 30, Farenheit = 86, Day=day};
            }
        }
    }

If we now create a client for this and ask for a forecast on a even day, it will work fine. If you ask for a forecast on an uneven day, you will get an error.

    namespace WeatherForeCastClient
    {
        class Program
        {
            static void Main(string[] args)
            {
                using (WeatherForeCastService.WeatherForeCastServiceClient client = new         WeatherForeCastService.WeatherForeCastServiceClient())
                {
                    WeatherForeCastService.WeatherForeCast weatherForeCast = client.GetWeatherForeCast(new DateTime(2011, 3, 24));
                    weatherForeCast = client.GetWeatherForeCast(new DateTime(2011, 3, 23));
                }
            }
        }
    }

The problem is that the client doesn't have any idea how the WeatherForeCastExtra object looks like or how it has to be deserialized. If we look at the WSDL our service generates, we can't find a definition for the WeatherForeCastExtra type.

It's kind of logic that we can't find a definition for the WeatherForeCastExtra type. If we look at our service interface, we see that the service returns the WeatherForeCast type. We have to find some way to tell the client that the service also returns something off the WeatherForeCastExtra type. This is were KnownType comes into action.

The KnownType attribute lets you specify types that should be include during serialization/deserialization. We have to use this attribute in our base class ( WeatherForeCast ).

    [KnownType(typeof(WeatherForeCastExtra))]
    [DataContract]
    public class WeatherForeCast
    {
        [DataMember]
        public int Celsius { get; set; }
    sdssdsds
        [DataMember]
        public DateTime Day { get; set; }
    }

If we now look at the generate WSDL file of our service, we will find a definition for our WeatherForeCastExtra type and the DataContractSerializer will know how the serialize or deserialize our WeatherForeCastExtra type.

If we run our client now, we won't get an exception on uneven days.

You can imagine that, if you have to include 10 types, your class would be decorated with 10 KnownType attributes and would be a little hard to read. This is why the KnownType attribute has another constructor. This constructor accepts a method name, as a string, of a static method that returns an array of types. These types will be include in the WDSL definition of the service.

    [KnownType("GetKnowTypes")]
    [DataContract]
    public class WeatherForeCast
    {
        [DataMember]
        public int Celsius { get; set; }

        [DataMember]
        public DateTime Day { get; set; }

        static Type[] GetKnowTypes()
        {
            return new Type[] { typeof(WeatherForeCastExtra) };
        }
    }

This will return the same WSDL as before and our client will still work.