Code

A WebServer for MonoTouch that also parses posted form data (HttpListenerRequest)

Peter Morris — Sat, 02 Apr 2011 17:58:14 GMT

I found a few examples of web servers for MonoTouch but none of them parsed the data sent in a POST request. I looked around the web and was unable to find any examples of how to achieve this. So now that I’ve written it myself I’ve decided to share my own implementation. This includes not only the code for processing the form post data but also for registering request handlers etc.

Here is an example of how you would use the web server

 1     public BookUploadViewController() 
 2       : base("BookUploadViewController", null)
 3     {
 4       RequestHandler = new DefaultRequestHandler();
 5       var defaultActionHandlerFactory = new DefaultActionHandlerFactory();
 6       RegisterActionHandlers(defaultActionHandlerFactory);
 7       RequestHandler.AddActionHandlerFactory(defaultActionHandlerFactory);
 8       
 9       WebServer = new EmbeddedWebServer(RequestHandler);
10     }
11     
12     void RegisterActionHandlers(DefaultActionHandlerFactory factory)
13     {
14       factory.RegisterHandler(
15         request => request.RawUrl == "/",
16         request => new IndexActionHandler(request)
17         );
18       factory.RegisterHandler(
19         request => 
20           string.Compare(request.RawUrl, "/Upload", true) == 0 && 
21           string.Compare(request.HttpMethod, "POST", true) == 0,
22         request => new UploadActionHandler(request)
23         );
24     }
25     
26     public override void ViewDidAppear(bool animated)
27     {
28       base.ViewDidAppear(animated);
29       StatusLabel.Text = string.Format("Server listening on\r\nhttp://{0}:8080", GetIPAddress ());
30       WebServer.Start(8080);
31     }
32     
33     public override void ViewDidDisappear (bool animated)
34     {
35       base.ViewDidDisappear(animated);
36       WebServer.Stop();
37     }
38

And here are two app specific examples of request handlers

 1 class IndexActionHandler : DefaultActionHandler
 2 {
 3   public IndexActionHandler(HttpListenerRequest request)
 4     : base(request)
 5   {
 6   }
 7   
 8   public override ActionResult Execute()
 9   {
10     var result = new HtmlResult();
11     result.AppendLine("<html>");
12     result.AppendLine("<body>");
13     result.AppendLine("<h1>Upload an image</h1>");
14     result.AppendLine("<form action='/Upload' enctype='multipart/form-data' method='post'>");
15     result.AppendLine ("<input name='Image' type='file'/><br/>");
16     result.AppendLine("<input name='Upload' type='submit' text='Upload'/>");
17     result.AppendLine("</form>");
18     result.AppendLine("</body>");
19     result.AppendLine("</html>");
20     return result;
21   }
22 }
23 
24 class UploadActionHandler : DefaultActionHandler
25 {
26   public UploadActionHandler(HttpListenerRequest request)
27     : base(request)
28   {
29   }
30 
31   public override ActionResult Execute()
32   {
33     string errorMessage = null;
34     var file = FormData.GetFile("Image");
35     if (file == null 
36       || file.FileData == null 
37       || file.FileData.Length == 0 
38       || string.IsNullOrEmpty(file.FileName))
39       errorMessage = "No image uploaded";
40     
41     if (errorMessage == null)
42       ProcessFile(file);
43       
44     var result = new HtmlResult();
45     result.AppendLine("<html>");
46     result.AppendLine("<body>");
47     if (errorMessage == null)
48       result.AppendLine("<h1>File uploaded successfully</h1>");
49     else
50     {
51       result.AppendLine("<h1>Error</h1>");
52       result.AppendLine("<h2>" + errorMessage + "</h2>");
53     }
54     result.AppendLine("</body>");
55     result.AppendLine("</html>");
56     return result;
57   }
58   
59   void ProcessFile(MultiPartStreamFileValue postedFile)
60   {
61     string fileName = "Where to save the file";
62     using (var fileStream = 
63       new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None))
64     {
65       fileStream.Write(postedFile.FileData, 0, postedFile.FileData.Length);
66     }
67   }
68   
69 }
70

You can download the files here.

Additional visualisations in ECO

Peter Morris — Thu, 10 Feb 2011 11:01:33 GMT

My model needs to take snapshots of certain data and to do this I have various snapshot classes.

Sometimes you might snapshot an aggregate root such as PurchaseOrder and expect all PurchaseOrderLines to be snapshotted along with it. Sometimes though the Parent/Child relationship is not part of an aggregate root and you want the child snapshot to create the parent snapshot, for example when snapshotting an Address you might want to snapshot the Country.

So when I was looking at my snapshot diagrams it wasn't immediately obviously which behaviour you get. Hans showed me this article: http://theblog.capableobjects.com/2009/12/catching-more-information-in-your-model.html

Now I have added symbols + tagged value definitions to my model and as a consequence the diagrams show me visually which way the snapshots work. Brilliant!

How many unique pizza combinations does Domino’s Pizza have?

Peter Morris — Mon, 10 Jan 2011 11:10:01 GMT

Okay, a weird topic I know but I saw a question asked in NewScientist querying whether the Domino’s Pizza claim of 1.8 billion combinations is possible. Here is the answer I am submitting:

If we have 4 options on the menu (ABCD) and choose 1 topping we have 4 unique combinations. If however we choose 2 toppings we have 6 unique combinations. As toppings in a different order are considered the same combination this means that when choosing the second topping we must choose from a sub-set of the entire menu. For example, when working out how many combinations start with A the second selection is limited to B..D, but when working out how many start with B the second selection is limited to C..D (because BA is the same combination as AB.) Domino's where I live has a menu of 21 toppings. So the valid options for the first selection when choosing 2 toppings are 1..20 (20 because we have 1 more selection to make after this), the valid options for the second selection are (first selection + 1)..21 (21 because there are no more selections to make after this.)

Not only does Domino's have 21 toppings on their menu, but you have the option of single/double which doubles the amount of options per topping, however you are only permitted a maximum of 9 toppings per pizza which brings the number of combinations down significantly.To bring the number of unique combinations back up again we have to take into account that the customer may order between 0..9 toppings, so we have to work out the iterations for each and add them together, where zero toppings is a single choice. Finally, in addition to the toppings you can choose from 3 sauces (single/double), 2 cheeses (single/double), and from 6 bases - increasing the total combinations by 6x4x6 = 144! I do not consider pizza size a “combination”.

I'm not much of a mathematician myself so I wrote a simple piece of recursive code to work out the result, which by the way is 200,407,536 - In short, the answer is "No."

And here is the source code to work it out:

 1     void ButtonCompute_Click(object sender, EventArgs e)
 2     {
 3       long combinations = 0;
 4       for (int toppingsToAdd = 1; toppingsToAdd <= 9; toppingsToAdd++)
 5         combinations += CalculateCombinations(21, toppingsToAdd);
 6 
 7       //Add one combination for "No toppings"
 8       combinations++;
 9 
10       //Take into account the non topping variations
11       combinations = combinations
12         * 6 //Multiply by 3 sauces, single or double
13         * 4 //Multiply by 2 cheeses, single or double
14         * 6; //Multiply by 6 bases
15       
16       textBox1.Text = string.Format("Combinations: {0}", combinations);
17     }
18 
19     long CalculateCombinations(int toppingsAvailable, int toppingsToAdd)
20     {
21       if (toppingsToAdd == 1)
22         return toppingsAvailable * 2; //Single or double
23 
24       long result = 0;
25       int toppingsToAddAfterThis = toppingsToAdd - 1;
26       checked
27       {
28         for (
29           //Start at highest value, e.g. 21 options
30           int currentChoice = toppingsAvailable;
31           //Keep enough options to fulfill the rest of the choices
32           currentChoice > toppingsToAddAfterThis;
33           currentChoice--)
34           result += CalculateCombinations(currentChoice - 1, toppingsToAddAfterThis);
35       }
36       return result;
37     }
38

Unity child containers + ASP MVC = Memory leak

Peter Morris — Sun, 19 Dec 2010 13:33:35 GMT

I was making some speed improvements to my current ASP MVC application. One of the things I did was to change from creating a completely new IUnityContainer for each request over to creating one master (template) container with all the services registered with HierarchicalLifetimeManager. Then whenever a controller is required my ControllerFactory does this

1 if (controllerType == null)
2   return null;
3 var requestContainer = Container.CreateChildContainer();
4 return (IController) requestContainer.Resolve(controllerType);

That’s all nice and simple, however it causes a memory leak. The reason is that the parent container holds a reference to all of its children. The only way to resolve this is to Dispose of the child container. Now obviously we cannot dispose of it in the controller factory because we need to return a fully working Controller. So the next thing I tried was to dispose of the request container in IControllerFactory.ReleaseController. The problem with this is that the controller is released before the view is rendered, so if your view depends on objects which retrieve their state from some kind of object space then this is too soon to dispose of the request container. So ultimately I couldn’t find anywhere in the ASP MVC framework into which I could hook an event which gets fired after the request has finished.

To solve the problem my IControllerFactory no longer returns the controller type requested. Instead at runtime it creates a descendant class which implements IController directly and then passes the request on to the original controller class. The type returned stores a reference to the per-request IUnityContainer and then does this

 1 void IController.Execute(RequestContext context)
 2 {
 3   try
 4   {
 5     base.Execute(context);
 6   }
 7   finally
 8   {
 9     RequestUnityContainer.Dispose();
10   }
11 }

So now we have a bit of code in our controller which disposes of the per-request unity container after the entire request has been processed. The ControllerFactory code only needs to be changed like so

1 protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
2 {
3   if (controllerType == null)
4     return null;
5   IUnityContainer requestContainer = Container.CreateChildContainer();
6   ControllerBase controller = ContainerDisposingControllerFactory.Create(requestContainer, controllerType);
7   return controller;
8 }

The code required is listed below…

  1 //ContainerDisposingControllerIntf.cs
  2 using Microsoft.Practices.Unity;
  3 
  4 namespace YourNameHere.Infrastructure.Web
  5 {
  6   public interface IContainerDisposingController
  7   {
  8     IUnityContainer IContainerDisposingController_UnityContainer { get; set; }
  9   }
 10 }
 11 
 12 
 13 //ContainerDisposingControllerFactory.cs
 14 using System;
 15 using System.Collections.Generic;
 16 using System.Linq;
 17 using System.Reflection;
 18 using System.Reflection.Emit;
 19 using System.Threading;
 20 using System.Web.Mvc;
 21 using Microsoft.Practices.Unity;
 22 
 23 namespace YourNameHere.Infrastructure.Web
 24 {
 25   public static class ContainerDisposingControllerFactory
 26   {
 27     const string UnityContainerBackingFieldName = "IContainerDisposingController_BackingField";
 28     static MethodInfo DisposeMethodInfo = typeof(IDisposable).GetMethod("Dispose");
 29     static readonly Dictionary<Type, Type> InterceptingType_BySuperClass = new Dictionary<Type, Type>();
 30     static ReaderWriterLockSlim Locker = new ReaderWriterLockSlim();
 31 
 32     public static ControllerBase Create(IUnityContainer containerToDispose, Type controllerType)
 33     {
 34       try
 35       {
 36         return CreateTypeAndInstance(containerToDispose, controllerType);
 37       }
 38       catch
 39       {
 40         containerToDispose.Dispose();
 41         throw;
 42       }
 43     }
 44 
 45     private static ControllerBase CreateTypeAndInstance(IUnityContainer containerToDispose, Type controllerType)
 46     {
 47       Type interceptingControllerType;
 48       Locker.EnterUpgradeableReadLock();
 49       try
 50       {
 51         if (!InterceptingType_BySuperClass.TryGetValue(controllerType, out interceptingControllerType))
 52         {
 53           Locker.EnterWriteLock();
 54           try
 55           {
 56             interceptingControllerType = CreateInterceptingControllerType(controllerType);
 57             InterceptingType_BySuperClass[controllerType] = interceptingControllerType;
 58           }
 59           finally
 60           {
 61             Locker.ExitWriteLock();
 62           }
 63         }
 64       }
 65       finally
 66       {
 67         Locker.ExitUpgradeableReadLock();
 68       }
 69 
 70       var result = (Controller)containerToDispose.Resolve(interceptingControllerType);
 71       var resultAsIUnityContainerController = (IContainerDisposingController)result;
 72       resultAsIUnityContainerController.IContainerDisposingController_UnityContainer = containerToDispose;
 73       return result;
 74     }
 75 
 76     static Type CreateInterceptingControllerType(Type controllerType)
 77     {
 78       if (!typeof(ControllerBase).IsAssignableFrom(controllerType))
 79         throw new ArgumentException("ControllerType does not descend from ControllerBase");
 80 
 81       string guid = Guid.NewGuid().ToString();
 82       var assemblyName = new AssemblyName(guid);
 83       var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
 84         assemblyName,
 85         AssemblyBuilderAccess.Run);
 86       var moduleBuilder = assemblyBuilder.DefineDynamicModule(guid);
 87       var typeBuilder = moduleBuilder.DefineType(
 88         guid,
 89         TypeAttributes.Class | TypeAttributes.Public,
 90         controllerType);
 91       CreateConstructor(controllerType, typeBuilder);
 92       FieldBuilder unityContainerBackingFieldBuilder;
 93       ImplementIContainerDisposingController(typeBuilder, out unityContainerBackingFieldBuilder);
 94       ImplementIController(controllerType, typeBuilder, unityContainerBackingFieldBuilder);
 95       return typeBuilder.CreateType();
 96     }
 97 
 98     static void CreateConstructor(Type controllerType, TypeBuilder typeBuilder)
 99     {
100       var constructorInfo = controllerType.GetConstructors()
101         .OrderByDescending(x => x.GetParameters().Count())
102         .FirstOrDefault();
103       if (constructorInfo == null)
104         return;
105       ParameterInfo[] constructorParameters =
106         constructorInfo.GetParameters().ToArray();
107       Type[] parameterTypes = constructorParameters.Select(x => x.ParameterType).ToArray();
108 
109       var constructorBuilder = typeBuilder.DefineConstructor(
110         MethodAttributes.Public,
111         CallingConventions.Standard,
112         parameterTypes);
113 
114       //Define the parameters for our new constructor
115       for (int argumentIndex = 0; argumentIndex < parameterTypes.Length; argumentIndex++)
116         constructorBuilder.DefineParameter(
117           argumentIndex + 1,
118           constructorParameters[argumentIndex].Attributes,
119           constructorParameters[argumentIndex].Name);
120 
121       var bodyGenerator = constructorBuilder.GetILGenerator();
122       bodyGenerator.Emit(OpCodes.Ldarg_0);
123       for (int argumentIndex = 0; argumentIndex < parameterTypes.Length; argumentIndex++)
124         bodyGenerator.Emit(OpCodes.Ldarg_S, argumentIndex + 1);
125       bodyGenerator.Emit(OpCodes.Call, constructorInfo);
126       bodyGenerator.Emit(OpCodes.Ret);
127     }
128 
129     static void ImplementIContainerDisposingController(TypeBuilder typeBuilder, out FieldBuilder unityContainerBackingFieldBuilder)
130     {
131       typeBuilder.AddInterfaceImplementation(typeof(IContainerDisposingController));
132       unityContainerBackingFieldBuilder = typeBuilder.DefineField(
133         UnityContainerBackingFieldName,
134         typeof(IUnityContainer),
135         FieldAttributes.Private);
136 
137       var propertyAccessorAttributes =
138         MethodAttributes.Public | MethodAttributes.SpecialName |
139         MethodAttributes.HideBySig | MethodAttributes.Virtual;
140 
141       var getterBuilder = typeBuilder.DefineMethod(
142         "get_IContainerDisposingController_UnityContainer",
143         propertyAccessorAttributes,
144         typeof(IUnityContainer),
145         Type.EmptyTypes);
146       var getterGenerator = getterBuilder.GetILGenerator();
147       getterGenerator.Emit(OpCodes.Ldarg_0);
148       getterGenerator.Emit(OpCodes.Ldfld, unityContainerBackingFieldBuilder);
149       getterGenerator.Emit(OpCodes.Ret);
150 
151       var setterBuilder = typeBuilder.DefineMethod(
152         "set_IContainerDisposingController_UnityContainer",
153         propertyAccessorAttributes,
154         null,
155         new Type[] { typeof(IUnityContainer) });
156       var setterGenerator = setterBuilder.GetILGenerator();
157       setterGenerator.Emit(OpCodes.Ldarg_0);
158       setterGenerator.Emit(OpCodes.Ldarg_1);
159       setterGenerator.Emit(OpCodes.Stfld, unityContainerBackingFieldBuilder);
160       setterGenerator.Emit(OpCodes.Ret);
161     }
162 
163     static void ImplementIController(Type controllerType, TypeBuilder typeBuilder, FieldBuilder unityContainerBackingFieldBuilder)
164     {
165       typeBuilder.AddInterfaceImplementation(typeof(IController));
166       MethodInfo baseMethod = null;
167       Type implementingType = controllerType;
168       do
169       {
170         baseMethod = implementingType.GetMethod(
171           "Execute",
172           BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
173         implementingType = implementingType.BaseType;
174       }
175       while (baseMethod == null && implementingType != null);
176       if (baseMethod == null)
177         throw new NotImplementedException(controllerType.Name + " does not implement IController.Execute");
178 
179       var methodParameters = baseMethod.GetParameters();
180       var methodBuilder = typeBuilder.DefineMethod(
181         typeof(IController).Name + ".Execute",
182         MethodAttributes.Public | MethodAttributes.Virtual |
183         MethodAttributes.ReuseSlot | MethodAttributes.HideBySig,
184         null,
185         methodParameters.Select(x => x.ParameterType).ToArray());
186       //Define the parameters for our new constructor
187       for (int argumentIndex = 0; argumentIndex < methodParameters.Length; argumentIndex++)
188         methodBuilder.DefineParameter(
189           argumentIndex + 1,
190           methodParameters[argumentIndex].Attributes,
191           methodParameters[argumentIndex].Name);
192 
193       var bodyGenerator = methodBuilder.GetILGenerator();
194       bodyGenerator.BeginExceptionBlock();
195       bodyGenerator.Emit(OpCodes.Ldarg_0);
196       for (int argumentIndex = 0; argumentIndex < methodParameters.Length; argumentIndex++)
197         bodyGenerator.Emit(OpCodes.Ldarg_S, argumentIndex + 1);
198       bodyGenerator.Emit(OpCodes.Call, baseMethod);
199       bodyGenerator.BeginFinallyBlock();
200       bodyGenerator.Emit(OpCodes.Ldarg_0);
201       bodyGenerator.Emit(OpCodes.Ldfld, unityContainerBackingFieldBuilder);
202       bodyGenerator.Emit(OpCodes.Call, DisposeMethodInfo);
203       bodyGenerator.EndExceptionBlock();
204       bodyGenerator.Emit(OpCodes.Ret);
205       typeBuilder.DefineMethodOverride(methodBuilder, baseMethod);
206     }
207   }
208 }

ASP MVC CheckListBox

Peter Morris — Fri, 26 Nov 2010 14:56:46 GMT

I needed to present the user with a list of objects from which they could select multiple items. There is a MultiSelectList class in ASP MVC so I looked into how to use that. It would seem that to use this class we need to use Html.ListBox. I think this is a poor choice because it requires the user to hold down the Control key to select additional options, and it is too easy to deselect all of your values accidentally by clicking the control accidentally without the Control key held down.

What I really wanted was something like a CheckListBox, a list of items with a check box next to them, so that’s what I have implemented. Here is an example of how to set up the view data for my CheckListBox extension.

  public ActionResult Index()
  {
    var availableItems = new List<MyItem>();
    availableItems.Add(new MyItem("A", "One"));
    availableItems.Add(new MyItem("B", "Two"));
    availableItems.Add(new MyItem("C", "Three"));
    availableItems.Add(new MyItem("D", "Four"));
    var selectedItems = availableItems.Skip(1).Take(2);
    ViewData["Items"] = CheckListBoxItems.Create(
      availableItems, 
      x => x.Code, 
      x => x.Name, 
      x => selectedItems.Contains(x));
    return View();
  }

  [HttpPost]
  public ActionResult Index(CheckListBoxItems items)
  {
    return Index();
  }

Make sure that when your application starts you register the custom binder for CheckListBoxItems

protected void Application_Start()
{
  ...
  ModelBinders.Binders.Add(
    typeof(CheckListBoxItems),
    new CheckListBoxItemsModelBinder());
}

Here is the first example of how you can mark up your view html.

<%: Html.CheckListBox("Items", (CheckListBoxItems)ViewData["Items"]) %>
<!-- Outputs the following HTML
<input type="hidden" name="Items[A].Key" value="A"/>
<input type="checkbox" name="Items[A].Selected" value="true"  />&nbsp;One<br/>
<input type="hidden" name="Items[B].Key" value="B"/>
<input type="checkbox" name="Items[B].Selected" value="true" checked />&nbsp;Two<br/>
<input type="hidden" name="Items[C].Key" value="C"/>
<input type="checkbox" name="Items[C].Selected" value="true" checked />&nbsp;Three<br/>
<input type="hidden" name="Items[D].Key" value="D"/>
<input type="checkbox" name="Items[D].Selected" value="true"  />&nbsp;Four<br/>
-->

And here is another example where you can pass in the HTML to use for each item in the list. The HTML is just a string used in String.Format where {0} is the check box html and {1} is where the text will be displayed. In the following example I pass the parameters in in the order 1,0 because I want the text first followed by the check box control.

<table>
  <tr>
    <th>Item</th>
    <th>Selected</th>
  </tr>
  <%: Html.CheckListBox(
    "Items", 
    (CheckListBoxItems)ViewData["Items"], 
    "<tr><td>{1}</td><td>{0}</td></tr>") %>
</table>
<!-- Outputs the following HTML
<table>
  <tr>
    <th>Item</th>
    <th>Selected</th>
  </tr>
  <tr>
    <td>One</td>
    <td>
      <input type="hidden" name="Items[A].Key" value="A"/>
      <input type="checkbox" name="Items[A].Selected" value="true"  />
    </td>
  </tr>
  <tr>
    <td>Two</td>
    <td>
      <input type="hidden" name="Items[B].Key" value="B"/>
      <input type="checkbox" name="Items[B].Selected" value="true" checked />
    </td>
  </tr>
  <tr>
    <td>Three</td>
    <td>
      <input type="hidden" name="Items[C].Key" value="C"/>
      <input type="checkbox" name="Items[C].Selected" value="true" checked />
    </td>
  </tr>
  <tr>
    <td>Four</td>
    <td>
      <input type="hidden" name="Items[D].Key" value="D"/>
      <input type="checkbox" name="Items[D].Selected" value="true"  />
    </td>
  </tr>
</table>
-->

Here is the source code:

//CheckListBoxItem.cs
using System.Collections.Generic;

namespace System.Web.Mvc
{
  public class CheckListBoxItem
  {
    public string Key { get; set; }
    public string Text { get; set; }
    public bool Selected { get; set; }
  }

  public class CheckListBoxItems : List<CheckListBoxItem>
  {
    public static CheckListBoxItems Create<T>(
      IEnumerable<T> source,
      Func<T, string> key,
      Func<T, string> text,
      Func<T, bool> selected)
    {
      var result = new CheckListBoxItems();
      foreach (T item in source)
      {
        CheckListBoxItem newItem = new CheckListBoxItem();
        result.Add(newItem);
        newItem.Key = key(item);
        newItem.Text = text(item);
        newItem.Selected = selected(item);
      }
      return result;
    }
  }
}

//CheckListBoxItems.cs
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace System.Web.Mvc.Html
{
  public static class CheckListBoxExtensions
  {
    public static MvcHtmlString CheckListBox(this HtmlHelper htmlHelper, string name, IEnumerable<CheckListBoxItem> items)
    {
      return htmlHelper.CheckListBox(name, items, "{0}&nbsp;{1}<br/>");
    }

    public static MvcHtmlString CheckListBox(this HtmlHelper htmlHelper, string name, IEnumerable<CheckListBoxItem> items, string itemFormat)
    {
      name = htmlHelper.Encode(name);
      var resultBuilder = new StringBuilder();
      var itemList = items.ToList();
      for (int index = 0; index < itemList.Count; index++)
      {
        CheckListBoxItem item = itemList[index];
        string encodedKey = htmlHelper.Encode(item.Key);
        string encodedText = htmlHelper.Encode(item.Text);
        string keyHtml =
          string.Format("<input type=\"hidden\" name=\"{0}[{1}].Key\" value=\"{2}\"/>", name, encodedKey, encodedKey);
        string checkBoxHtml =
          string.Format(
            "<input type=\"checkbox\" name=\"{0}[{1}].Selected\" value=\"true\" {2} />",
            name, encodedKey, item.Selected ? "checked" : "");
        resultBuilder.AppendFormat(itemFormat, keyHtml + checkBoxHtml, encodedText);
      }
      return MvcHtmlString.Create(resultBuilder.ToString());
    }
  }
}

//CheckListBoxItemsModelBinder.cs
using System.Linq;
using System.Text.RegularExpressions;

namespace System.Web.Mvc
{
  public class CheckListBoxItemsModelBinder : IModelBinder
  {
    public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
      var result = new CheckListBoxItems();
      string modelName = bindingContext.ModelName;
      string regexKeyPattern = "^" + modelName + @"\[.+?\]\.Key$";
      var keyRegex = new Regex(regexKeyPattern, RegexOptions.IgnoreCase);
      var keys = controllerContext.RequestContext.HttpContext.Request.Form.AllKeys.Where(x => keyRegex.IsMatch(x));
      foreach (string key in keys)
      {
        var valueSubmittedForKey = bindingContext.ValueProvider.GetValue(key);
        bindingContext.ModelState.SetModelValue(key, valueSubmittedForKey);

        string valueKey = key.Substring(0, key.Length - 4) + ".Selected";
        var valueSubmittedForValueKey = bindingContext.ValueProvider.GetValue(valueKey);
        bindingContext.ModelState.SetModelValue(valueKey, valueSubmittedForValueKey);

        var checkListBoxItem = new CheckListBoxItem();
        result.Add(checkListBoxItem);
        checkListBoxItem.Key = valueSubmittedForKey.AttemptedValue;
        checkListBoxItem.Selected = valueSubmittedForValueKey != null;
      }
      return result;
    }
  }
}

ASP MVC encoding route values

Peter Morris — Sat, 20 Nov 2010 21:30:53 GMT

I’ve recently been using ASP MVC 2 to develop a business application. As you may already know the ASP MVC routing system works with URLs which look like this

http://localhost/Client/Details/IBM

In standard ASPX apps the URL would look more like this

http://localhost/Client/Details.aspx?code=IBM

The first URL obviously looks much nicer than the 2nd, however it comes at a cost. What if the “code” of your object is something like “N/A” for “Not applicable”? You end up with a URL that looks like this

http://localhost/AbsenceCode/Details/N/A

What we really need is to have ASP MVC encode the value “N/A” as “N%2FA”. The problem is that even if it did do this then by the time ASP MVC receives the value it has already been decoded, so we get a “400 bad request” error. This is a real pain, because in business we can’t really tell a customer “You can only use characters A to Z, 0 to 9, underscore and minus in your codes” because they will tell you that they have used the code N/A for not-applicable for the past 20 years.

Now if the code had been after the ? in the URL (a query string value) it would get encoded/decoded and there would be no problem, but unfortunately ASP MVC won’t allow you to include ? in your routes. So I spent today working on a solution to this and it looks like I’ve just cracked it. It requires the following…

//1: Register a custom value provider in global.asax.cs
protected void Application_Start()
{
  EncodedRouteValueProviderFactory.Register();
  ...
}

//2: Use the following code in your views instead of Html.ActionLink
//this will ensure that all values before the ? query string part of your
//URL are properly encoded

<%: Html.EncodedActionLink(.....) %>
//3: Use this special redirect action when redirecting from a method
return this.EncodedActionLink(.....);

Those are the only changes required to your web app. In fact they are so simple that you should be able to change your app in seconds with a find/replace in files.

I’ll list all of my code below, there are two hacky bits. In one place I type cast an IRoute to a Route object so that I can get its URL, and in another place I use reflection so that I can set two properties which have a protected setter. The trick is to ensure that whenever we produce a URL in our website it encodes any special characters before the ?, we can’t use %xx so I use !xx. In the above example N/A would become N!2fA, if the value N/A appears after the ? then it will be URL encoded as normal (N%2fA). When the user navigates to a new page these route values are passed in this specially encoded format so they need to be converted back, so I register my own ValueProvider which looks at the current route (e.g. {controller}/{action}/{make}/{model}/{registration}) and decodes all values which appear in the route only. This is done only once (the first time any value is requested) so N!2fA will be converted back to N/A as if we had been passed that value to start with.

I only finished working on this last night, but it seems to be working okay in my current app though. If you spot any bugs in my source or add any missing features make sure to let me know on my gmail.com account (mrpmorris).

//EncodedActionLinkExtensions.cs
using System.Text;
using System.Text.RegularExpressions;
using System.Web.Routing;

namespace System.Web.Mvc.Html
{
  public static class EncodedActionLinkExtensions
  {
    public static MvcHtmlString EncodedActionLink(this HtmlHelper htmlHelper, string linkText, string action)
    {
      return htmlHelper.EncodedActionLink(linkText, action, (object)null);
    }

    public static MvcHtmlString EncodedActionLink(this HtmlHelper htmlHelper, string linkText, string action, string controllerName)
    {
      return htmlHelper.EncodedActionLink(linkText, action, controllerName, (object)null);
    }

    public static MvcHtmlString EncodedActionLink(this HtmlHelper htmlHelper, string linkText, string action, object explicitRouteValues)
    {
      object routeValueObj;
      if (!htmlHelper.ViewContext.RequestContext.RouteData.Values.TryGetValue("controller", out routeValueObj))
        throw new InvalidOperationException("Could not determine controller");

      string controllerName = (string)routeValueObj;
      return htmlHelper.EncodedActionLink(linkText, action, controllerName, explicitRouteValues);
    }

    public static MvcHtmlString EncodedActionLink(this HtmlHelper htmlHelper, string linkText, string action, string controllerName, object explicitRouteValues)
    {
      return htmlHelper.EncodedActionLink(linkText, action, controllerName, new RouteValueDictionary(explicitRouteValues));
    }

    public static MvcHtmlString EncodedActionLink(this HtmlHelper htmlHelper, string linkText, string action, string controllerName, RouteValueDictionary explicitRouteValues)
    {
      string url = EncodedUrlHelper.GenerateUrl(
        htmlHelper.ViewContext.RequestContext,
        controllerName, action, explicitRouteValues);
      string result = string.Format("<a href=\"{0}\">{1}</a>", url, linkText);
      return MvcHtmlString.Create(result);
    }
  }
}


//EncodedRedirectToRouteExtensions.cs
using System.Web.Routing;
namespace System.Web.Mvc
{
  public static class EncodedRedirectToRouteExtensions
  {
    public static EncodedRedirectToRouteResult EncodedRedirectToAction(this IController controller, string actionName)
    {
      return controller.EncodedRedirectToAction(
        actionName,
        (string)null, //controllerName,
        (RouteValueDictionary)null //routeValues
        );
    }

    public static EncodedRedirectToRouteResult EncodedRedirectToAction(this IController controller, string actionName, object routeValues)
    {
      return controller.EncodedRedirectToAction(
        actionName,
        (string)null, //controllerName,
        new RouteValueDictionary(routeValues)
        );
    }

    public static EncodedRedirectToRouteResult EncodedRedirectToAction(this IController controller, string actionName, RouteValueDictionary routeValues)
    {
      return controller.EncodedRedirectToAction(
        actionName,
        (string)null, //controllerName,
        routeValues
        );
    }

    public static EncodedRedirectToRouteResult EncodedRedirectToAction(this IController controller, string actionName, string controllerName)
    {
      return controller.EncodedRedirectToAction(
        actionName,
        controllerName,
        (RouteValueDictionary)null //routeValues
        );
    }

    public static EncodedRedirectToRouteResult EncodedRedirectToAction(this IController controller, string actionName, string controllerName, object routeValues)
    {
      return controller.EncodedRedirectToAction(
        actionName,
        controllerName,
        new RouteValueDictionary(routeValues)
        );
    }

    public static EncodedRedirectToRouteResult EncodedRedirectToAction(this IController controller, string actionName, string controllerName, RouteValueDictionary routeValues)
    {
      RouteValueDictionary dictionary;
      if (routeValues != null)
        dictionary = new RouteValueDictionary(routeValues);
      else
        dictionary = new RouteValueDictionary();
      dictionary["controller"] = controllerName;
      dictionary["action"] = actionName;

      var result = new EncodedRedirectToRouteResult(dictionary);
      return result;
    }

  }
}

//EncodedRedirectToRouteResult.cs
using System.Web.Mvc;
using System.Web.Routing;
namespace System.Web.Mvc
{
  public class EncodedRedirectToRouteResult : ActionResult
  {
    readonly string RouteName;
    readonly RouteValueDictionary RouteValues;

    public EncodedRedirectToRouteResult(RouteValueDictionary routeValues)
      : this(null, routeValues)
    {
    }

    public EncodedRedirectToRouteResult(string routeName, RouteValueDictionary routeValues)
    {
      RouteName = routeName ?? "";
      RouteValues = routeValues != null ? routeValues : new RouteValueDictionary();
    }

    public override void ExecuteResult(ControllerContext context)
    {
      string url = EncodedUrlHelper.GenerateUrl(context.RequestContext, null, null, RouteValues);
      context.Controller.TempData.Keep();
      context.HttpContext.Response.Redirect(url, false);
    }
  }
}

//EncodedRouteValueProvider.cs
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Web.Routing;
using System.Reflection;
namespace System.Web.Mvc
{
  public class EncodedRouteValueProvider : IValueProvider
  {
    readonly ControllerContext ControllerContext;
    bool Activated = false;

    public EncodedRouteValueProvider(ControllerContext controllerContext)
    {
      ControllerContext = controllerContext;
    }

    public bool ContainsPrefix(string prefix)
    {
      if (!Activated)
        DecodeRouteValues();
      return false;
    }

    public ValueProviderResult GetValue(string key)
    {
      if (!Activated)
        DecodeRouteValues();
      return null;
    }

    void DecodeRouteValues()
    {
      Activated = true;
      var route = (Route)ControllerContext.RouteData.Route;
      string url = route.Url;
      var keysToDecode = new HashSet<string>();
      var regex = new Regex(@"\{.+?\}");
      foreach (Match match in regex.Matches(url))
        keysToDecode.Add(match.Value.Substring(1, match.Value.Length - 2));
      foreach (string key in keysToDecode)
      {
        object valueObj = ControllerContext.RequestContext.RouteData.Values[key];
        if (valueObj == null)
          continue;
        string value = valueObj.ToString();
        value = UrlValueEncoderDecoder.DecodeString(value);
        ControllerContext.RouteData.Values[key] = value;
        ValueProviderResult valueProviderResult = ControllerContext.Controller.ValueProvider.GetValue(key);
        if (valueProviderResult == null)
          continue;
        PropertyInfo attemptedValueProperty = valueProviderResult.GetType().GetProperty("AttemptedValue");
        attemptedValueProperty.SetValue(valueProviderResult, value, null);
        PropertyInfo rawValueProperty = valueProviderResult.GetType().GetProperty("RawValue");
        rawValueProperty.SetValue(valueProviderResult, value, null);
      }
    }

  }
}

//EncodedRouteValueProviderFactory.cs
namespace System.Web.Mvc
{
  public class EncodedRouteValueProviderFactory : ValueProviderFactory
  {
    public override IValueProvider GetValueProvider(ControllerContext controllerContext)
    {
      return new EncodedRouteValueProvider(controllerContext);
    }

    public static void Register()
    {
      ValueProviderFactories.Factories.Insert(0, new EncodedRouteValueProviderFactory());
    }
  }
}

//EncodedUrlHelper.cs
using System.Text;
using System.Text.RegularExpressions;
using System.Web.Mvc;
namespace System.Web.Routing
{
  public static class EncodedUrlHelper
  {
    public static string GenerateUrl(
      RequestContext requestContext, 
      string controllerName,
      string action,
      RouteValueDictionary explicitRouteValues)
    {
      if (requestContext == null)
        throw new ArgumentNullException("RequestContext");

      var newRouteValues = RouteHelper.GetRouteValueDictionary(
        requestContext, controllerName, action, explicitRouteValues);
      var route = RouteHelper.GetRoute(requestContext, controllerName, action, newRouteValues);
      string url = route.Url;
      //Replace the {values} in the main part of the URL with request values
      var regex = new Regex(@"\{.+?\}");
      url = regex.Replace(url,
        match =>
        {
          string key = match.Value.Substring(1, match.Value.Length - 2);
          object value;
          if (!newRouteValues.TryGetValue(key, out value))
            throw new ArgumentNullException("Cannot reconcile value for key: " + key);
          string replaceWith;
          if (value == UrlParameter.Optional)
            replaceWith = "";
          else
            replaceWith = UrlValueEncoderDecoder.EncodeObject(value);
          explicitRouteValues.Remove(key);
          return replaceWith;
        });

      //2: Add additional values after the ?
      explicitRouteValues.Remove("controller");
      explicitRouteValues.Remove("action");
      var urlBuilder = new StringBuilder();
      urlBuilder.Append("/" + url);
      string separator = "?";
      foreach (var kvp in explicitRouteValues)
      {
        if (kvp.Value != UrlParameter.Optional)
        {
          urlBuilder.AppendFormat("{0}{1}={2}", separator, kvp.Key, kvp.Value == null ? "" : HttpUtility.UrlEncode(kvp.Value.ToString()));
          separator = "&";
        }
      }
      return urlBuilder.ToString();
    }
  }
}

//RouteHelper.cs
namespace System.Web.Routing
{
  public static class RouteHelper
  {
    public static RouteValueDictionary GetRouteValueDictionary(
      RequestContext requestContext,
      string controllerName,
      string action,
      RouteValueDictionary explicitRouteValues)
    {
      var newRouteValues = new RouteValueDictionary();
      var route = GetRoute(requestContext, controllerName, action, explicitRouteValues);
      MergeValues(route.Defaults, newRouteValues);
      MergeValues(requestContext.RouteData.Values, newRouteValues);
      if (explicitRouteValues != null)
        MergeValues(explicitRouteValues, newRouteValues);
      if (controllerName != null)
        newRouteValues["controller"] = controllerName;
      if (action != null)
        newRouteValues["action"] = action;
      return newRouteValues;
    }

    public static Route GetRoute(
      RequestContext requestContext,
      string controllerName,
      string action,
      RouteValueDictionary explicitRouteValues
      )
    {
      var routeValues = new RouteValueDictionary(requestContext.RouteData.Values);
      if (explicitRouteValues != null)
        MergeValues(explicitRouteValues, routeValues);
      if (controllerName != null)
        routeValues["controller"] = controllerName;
      if (action != null)
        routeValues["action"] = action;
      var virtualPath = RouteTable.Routes.GetVirtualPath(requestContext, routeValues);
      return (Route)virtualPath.Route;
    }

    static void MergeValues(RouteValueDictionary routeValues, RouteValueDictionary result)
    {
      foreach (var kvp in routeValues)
      {
        if (kvp.Value != null)
          result[kvp.Key] = kvp.Value;
        else
        {
          object value;
          if (!result.TryGetValue(kvp.Key, out value))
            result[kvp.Key] = null;
        }
      }
    }
  }
}

//UrlValueEncoderDecoder.cs
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;
namespace System.Web.Mvc
{
  public static class UrlValueEncoderDecoder
  {
    static HashSet<char> ValidChars;

    static UrlValueEncoderDecoder()
    {
      string chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-.";
      ValidChars = new HashSet<char>(chars.ToCharArray());
    }

    public static string EncodeObject(object value)
    {
      if (value == null)
        return null;
      return EncodeString(value.ToString());
    }

    public static string EncodeString(string value)
    {
      if (value == null)
        return null;
      var resultBuilder = new StringBuilder();
      foreach (char currentChar in value.ToCharArray())
        if (ValidChars.Contains(currentChar))
          resultBuilder.Append(currentChar);
        else
        {
          byte[] bytes = System.Text.UnicodeEncoding.UTF8.GetBytes(currentChar.ToString());
          foreach (byte currentByte in bytes)
            resultBuilder.AppendFormat("${0:x2}", currentByte);
        }
      string result = resultBuilder.ToString();
      //Special case, use + for spaces as it is shorter and spaces are common
      return result.Replace("$20", "+");
    }

    public static string DecodeString(string value)
    {
      if (value == null)
        return value;
      //Special case, change + back to a space
      value = value.Replace("+", " ");
      var regex = new Regex(@"\$[0-9a-fA-F]{2}");
      value = regex.Replace(value,
        match =>
        {
          string hexCode = match.Value.Substring(1, 2);
          byte byteValue = byte.Parse(hexCode, NumberStyles.AllowHexSpecifier);
          string decodedChar = System.Text.UnicodeEncoding.UTF8.GetString(new byte[] { byteValue });
          return decodedChar;
        });
      return value;
    }
  }
}

Delphi Audio Compression components updated to Delphi 2009

Peter Morris — Tue, 01 Sep 2009 12:04:51 GMT

Diego has upgraded my deACM source to work with Delphi 2009.

http://unitonedev.blogspot.com/2009/08/deaudio-convertido-para-delphi-2009.html

Partial declarations of must not specify different base classes

Peter Morris — Thu, 23 Jul 2009 11:08:31 GMT

I wanted to use a common base class for a set of UserControls in my WPF application, but when I changed the class’s ancestor in the code file and compiled I would get the error

“Partial declarations of must not specify different base classes”

This is because when you compile a WPF application Visual Studio generates a partial class in a code-behind file automatically, the base type specified is always “UserControl”. To solve this problem change your XAML from this

   1:  <UserControl

   2:    x:Class="MyApp.MyControl"

   3:  />

To this

   1:  <local:SomeBaseTypeYouWantToUse

   2:    x:Class="MyApp.MyControl"

   3:    xmlns:local="clr-namespace:NameSpace.To.Your.BaseClass"

   4:  />

Models, views, controllers

Peter Morris — Fri, 17 Jul 2009 15:38:52 GMT

I’m working on a new app which will have WPF as its user interface. With the slight nag in the back of my mind that someone might say “No, we want WinForms” (I hope not) I decided there should be as little code in the UI as possible so I opted for a view/controller approach where my controller will perform all of the logic and the view will only do “viewy” things.

One of the features of this app is that some of the views should appear as modal windows (such as a splash window during start-up) but others should appear as tabs in a client area so that the user can switch between different tasks. So I created a UserControl which data bound to a list of IView, there were two problems with this approach.

Firstly I wanted my IView implementers to be UserControls so that when I data bind to the List<IView> the content of the TabItem would show the correct control. The problem was that I needed the header of the TabItem to be data bound too…

   1:  <TabControl.ItemTemplate>

   2:      <DataTemplate>

   3:          <TextBlock Text="{Binding ViewTitle}"/>

   4:      </DataTemplate>

   5:  </TabControl.ItemTemplate>

So all I need is a string property on IView named ViewTitle and all would be well. Or so you would think! Data binding a TabControl to a list of objects which happen to be UserControl descendants doesn’t work very well, as a result the ItemTemplate was unable to read my property. Even if I converted it to a DependencyProperty it still didn’t work. It seems it is a problem with the way the WPF TabControl was written.

Secondly there was a problem when it came to wizard like views. When one of my tabs needs multiple steps how can I change the view? I can’t!

The solution was instead to data bind the TabControl to a list of controllers instead. Seeing as I already have IController for controllers which have modal views I went for List<IEmbeddedController> instead.

   1:  public interface IController : INotifyPropertyChanged

   2:  {

   3:      IView CurrentView { get; }

   4:  }

5:

   6:  public interface IEmbeddedController : IController

   7:  {

   8:      string ViewTitle { get; }

   9:  }

Now I can bind my TabItem.ItemTemplate to ViewTitle with no problem because it is not binding to a UserControl but a plain object instead. In addition the IEmbeddedController can set its CurrentView property at any point in order to show a different presentation to the user.

   1:  <TabControl.ContentTemplate>

   2:      <DataTemplate>

   3:          <ContentPresenter Content="{Binding CurrentView}" />

   4:      </DataTemplate>

   5:  </TabControl.ContentTemplate>

Now my tabbed views function correctly. I see a title on the tab item and the contents of the view. The next thing to address is how does the controller know which view to set CurrentView to? I do that using Unity dependency injection. So, for example, if I were to create a controller named “WizardTest” with two steps I would have the following items…

IStep1View
Step1Control (implements IStep1View)
IStep2View
Step2Control (implements IStep2View)
IWizardTestController
WizardTestController (implements IWizardTestController)

In the start-up phase of my application I would register which classes implement those interfaces…

   1:  static void RegisterWizardTestViewAndController(IUnityContainer container)

   2:  {

   3:      container.RegisterType

   4:          <

   5:              MyApp.Views.WizardTest.IWizardTestController,

   6:              MyApp.Views.WizardTest.WizardTestController

   7:          >(new TransientLifetimeManager());

   8:      container.RegisterType

   9:          <

  10:              MyApp.Views.WizardTest.Steps.IStep1View,

  11:              MyApp.Views.WizardTest.Steps.Step1

  12:          >(new TransientLifetimeManager());

  13:      container.RegisterType

  14:          <

  15:              MyApp.Views.WizardTest.Steps.IStep2View,

  16:              MyApp.Views.WizardTest.Steps.Step2

  17:          >(new TransientLifetimeManager());

  18:  }

When I need to show one of the states I write code something like this…

   1:  IStep1View Step1View;

   2:  private void SetStep1View()

   3:  {

   4:      if (Step1View == null)

   5:      {

   6:          Step1View = ViewFactory.CreateView<IStep1View>();

   7:          Step1View.Initialize(SomeModelObjectToEdit);

   8:      }

   9:      CurrentView = Step1View;

  10:  }

I can update the view on the screen simply by changing the CurrentView property. Let’s say that the Step1Control needs a NEXT button. This is easily achieved like so…

   1:  public interface IStep1View : IView

   2:  {

   3:      ICommand NextCommand { get; set; }

   4:  }

ICommand is an interface that WPF uses to bind UI actions to, for example in Step1Control I implement the property required by IStep1View and in the XAML I add a button like this…

   1:  <Button Content="Go to step 2" Command="{Binding CurrentView.NextCommand}"/>

CurrentView because (remember) the control is bound to the IEmbeddedController so we need the NextCommand of the CurrentView. When the user clicks this button it will execute the ICommand.Execute. This means that I don’t need a Button.Click event in the XAML, I don’t need to handle the event in the code-behind class, and I don’t need some kind of NextButtonClicked event on IStep1View - although I do instead need a NextCommand property instead, but all in all there’s less work…

   1:  IStep2View Step1View;

   2:  private void SetStep1View()

   3:  {

   4:      if (Step1View == null)

   5:      {

   6:          Step1View = ViewFactory.CreateView<IStep1View>();

   7:          Step1View.Initialize(SomeModelObjectToEdit);

   8:          Step1View.NextCommand = new ActionCommand(p => State = States.Step2);

   9:      }

  10:      CurrentView = Step1View;

  11:  }

ViewFactory is a very simple class which asks Unity to Resolve<> the type passed. This not only gives me simple construction but also injects any dependencies. ActionCommand is also a simple class which uses a lambda expression as its action to execute:

   1:  public class ActionCommand : ICommand

   2:  {

   3:      readonly Action<object> Action;

   4:      public event EventHandler CanExecuteChanged;

5:

   6:      public ActionCommand(Action<object> action)

   7:      {

   8:          Action = action;

   9:          Enabled = true;

  10:      }

11:

  12:      bool enabled;

  13:      public bool Enabled

  14:      {

  15:          get { return enabled; }

  16:          set

  17:          {

  18:              enabled = value;

  19:              var canExecuteChanged = CanExecuteChanged;

  20:              if (canExecuteChanged != null)

  21:                  canExecuteChanged(this, EventArgs.Empty);

  22:          }

  23:      }

24:

  25:      public bool CanExecute(object parameter)

  26:      {

  27:          return Enabled;

  28:      }

29:

  30:      public void Execute(object parameter)

  31:      {

  32:          Action(parameter);

  33:      }

  34:  }

Clicking the button in the UserControl executes the NextCommand.Execute method, this is a lambda which sets State = States.Step2. The property “State” has a switch statement and calls SetStep1View, SetStep2View etc depending on the state that has been set.

Finally the management of the tabbed views, and how to show new views from other controllers. I did this with a service I called “IEmbeddedControllerPresenterController” because it is a controller which presents Embedded Controllers.

   1:  public interface IEmbeddedControllerPresenterController

   2:  {

   3:      void AddController(IEmbeddedController controller);

   4:      void RemoveController(IEmbeddedController controller);

   5:      void FocusController(IEmbeddedController controller);

   6:      UserControl UserControl { get; }

   7:  }

I’m going to change the “UserControl UserControl” property to “IView View'” very soon. But the idea is that this is registered in Unity with a ContainerControlledLifetimeManager (effectively a singleton). I can add and remove controllers from the list which my TabControl is bound to, and also specify which one should be focused.

Now when it comes to creating new views I use an IEmbeddedControllerRepository. It’s a repository because I don’t always create the embedded controller. When asking for a controller I pass a unique “InstanceID” which could be something simple like “NewCustomer” / “NewSupplier”, or when editing an instance of a user it could be the primary key of that user instance. This is to ensure that when you want a controller to edit “User A” and the interface already has a view editing that object the existing view will focus, if there is no view present for this object a new one will be created by calling a factory (simply delegates to Unity).

   1:  public interface IEmbeddedControllerRepository

   2:  {

   3:      TController GetController<TController>(string instanceID) where TController : IEmbeddedController;

   4:      void ReleaseController(string instanceID);

   5:  }

Two examples of using this might be…

   1:  var repository = EmbeddedUserRepository;

2:

   3:  //Example 1 - only create 1 new user at a time

   4:  repository.GetController<INewUserController>("NewUser");

5:

   6:  //Example 2 - edit any number of users, but never the same one twice

   7:  User user = .........;

   8:  var controller = repository.GetController<IEditUserController>(user.UniqueID);

   9:  controller.Initialize(user);

All of this is really just a slight variation of an approach I took for a wizard driven application I once wrote for the Pocket PC. The only difference is that the views are tabbed (whereas the PPC they were stacked and only 1 was visible at a time), and in this I am using Unity so that I can modularise the code a bit and potentially get some mocked objects in there via the interface definitions so that I can unit test more easily.

I’ve read (http://tech.groups.yahoo.com/group/domaindrivendesign/message/13738) that you should only have one controller per application. I simply don’t think this is true. While I do believe it is sometimes necessary to have a single controller responsible for multiple views I don’t think there are many apps which require only a single controller. E.g. if you are modelling a 3D scene and want to see a live preview of the scene in one window and sliders etc to control the camera angle you would use one controller, but if you are editing a customer, a supplier, and an employee you will need three different types of controller, and one instance of a controller per object you are editing in isolation.

TaskSmart

Peter Morris — Sat, 27 Jun 2009 16:56:17 GMT

Carlo Kok from RemObjects suggested a book to me “Getting things done” a while back (I’d recommend it too) – since then I have been using Get On Tracks, which is a web based app based on the suggestions in the book. It’s a pretty good app but I find it is very slow, painfully slow. So, due to the relentless part of my personality which compels me to constantly learn new things I have started an open source project on sourceforge.net – TaskSmart. This will be a web app I can use as a replacement for Get On Tracks, so I will get a faster app (hopefully) and also get to play with some new things along the way.

The ingredients for this application will be

ASP MVC
AJAX – Not used it before, possibly using jQuery
Domain Driven Design – Only a few items I liked from the book
UNITY – Dependency injection container
NHibernate – Not used this before either
Rhino Mocks – Used this quite a lot
Test Driven Design – A must have!
AutoMapper – To map domains to view model

The web interface will be handled by ASP MVC controllers.
These controllers will present a View Model to the interface.
The controller will talk to the Application Layer using View Model instances as parameters.
I think I will use AutoMapper to help the Application Layer to translate between Domain Classes and View Model.
The Application Layer will act as a facade to the Domain classes.
The Application Layer will manage all persistence using NHibernate.

In addition all dependencies will be injected using UNITY from Microsoft, this will make testing easier and also make it easier to compartmentalise the source code into smaller chunks which are easier to understand.

I have decided to manage constraints as individual objects, for example

StringIsNotNullConstraint
StringIsNotTooLongConstraint
StringIsNotTooShortConstraint
StringIsValidInternetEmailAddressConstraint

Previously I would have used object constraint language expressions and return a list of broken constraints as a collection of strings. This would mean that when I validate user input I would either have to manually reproduce the business constraints in the user interface (which is a pain when they need to change) or not validate on the client at all and leave it all to the server (which results in a wasted server request when we know for a fact that the user input will be rejected). So my idea here is that if my constraints are objects then I will be able to determine two things about the constraints.

The way in which the constraint logically checks a value, such as “This string must be at least X characters in length”.
The relevant properties of the constraint, such as exactly what the minimum number of characters is.

What I am hoping to do with this additional information is then to

Define the constraints on my domain classes.
AutoMap the relevant constraints to the View Model.
Automatically convert these constraints into JavaScript.
Have the client validate input in the web browser before it is submitted to the server for final validation.

This should give me the advantage of not having to waste server resources on a certainly invalid request, and also save me from having to define constraints in more than one place; updating on the domain class will automatically update the validation on the page.

It’s all a pretty tall order, but it should be interesting to say the least!