2012-08-29

ASP MVC Silverlight control not appearing–404 not found

Just a quick tip in case you have deployed your ASP MVC app with silverlight controls in it which are not appearing.  I experienced this recently when deploying to IIS6.  The solution is Open the IIS manager app (Start->Admin->Internet Information Services (IIS) Manager) Expand the local computer node Then expand the Websites nodes Right-click your website and select “Properties” Click the “Http Headers” tab At the bottom of the page click the “MIME Types” button Click the...

Creating a pooled lifetime manager for Unity

My application has a child container per request, this is because there are a lot of services used in each request which depend upon an IUnitOfWork.  I thought it would be nice if I could define a pool of these IUnitOfWork instances so that any cost involved in creating them is reduced, they can just be reused in a round-robin fashion.  Well, more accurately, the object space (EcoSpace) on which they depend can anyway.

A pool can now be registered like so…

//Must be called once, when the container is created
container.AddNewExtension<PooledLifetimeExtension>();
//To register a pooled item
container.RegisterType
<
ISomeItemThatIsExpensiveToCreate,
SomeItemThatIsExpensiveToCreate
>(new PooledLifetimeManager());


The number 10 specifies how many instances at once may be stored in the pool.  If an instance requests an item from the pool when it is empty it will get a new instance, it’s only at the point where an instance is returned to the pool that the MaxPoolSize is honoured – if the pool is not full then the instance goes back into the pool, if the pool is already full then Dispose is called on it instead.  Of course you should be careful when pooling that your pooled items don’t hold onto other injected references which are also pooled as that will cause problems.



I have also added the following interface so that an instance can (optionally) specify whether or not its current state should permit it to go back into the pool, and two methods which indicate to the instance when it has been retrieved from a pool or is about to be returned to the pool – in my case I deactivated the object space upon returning in order to flush any object cache, and reactivated it again when retrieved from the pool.



public interface IPooledResource
{
bool CanReturnToPool { get; }
void RetrievedFromPool();
void ReturningToPool();
}


It’s important to note that this only works with child containers.  You should create your main controller as a kind of template by registering your request specific services (like IUnitOfWork) with HierarchicalLifetimeManager.  The PooledLifetimeManager will work in the same way as HierarchicalLifetimeManager except for the addition of pooling, and it will automatically attempt to return items to the pool once the child container is disposed of.



//PooledLifetimeExtension.cs
using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.ObjectBuilder;

namespace YourNameHere.Infrastructure.Unity
{
public class PooledLifetimeExtension : UnityContainerExtension
{
protected override void Initialize()
{
// Add to type mapping stage so that it runs before the lifetime stage
Context.Strategies.AddNew<PooledLifetimeStrategy>
(UnityBuildStage.TypeMapping);
}
}
}



//PooledLifetimeManager.cs
using System;
using System.Collections.Generic;
using Microsoft.Practices.Unity;
using Microsoft.Practices.ObjectBuilder;

namespace YourNameHere.Infrastructure.Unity
{
public class PooledLifetimeManager : LifetimeManager
{
readonly PooledLifetimeManagerPool Pool;

public PooledLifetimeManager(int maxPoolSize)
{
Pool
= new PooledLifetimeManagerPool(maxPoolSize);
}

internal PooledLifetimeManagerPoolConsumer CreatePoolUserForChildContainer()
{
return new PooledLifetimeManagerPoolConsumer(Pool);
}

#region GetValue/SetValue/RemoveValue all redundant
public override object GetValue()
{
throw new InvalidOperationException();
}

public override void SetValue(object newValue)
{
throw new InvalidOperationException();
}

public override void RemoveValue()
{
throw new InvalidOperationException();
}
#endregion
}

internal class PooledLifetimeManagerPool
{
readonly int MaxPoolSize;
readonly object SyncRoot = new object();
readonly Queue<object> Queue = new Queue<object>();

public PooledLifetimeManagerPool(int maxPoolSize)
{
if (maxPoolSize < )
throw new ArgumentOutOfRangeException(
"MaxPoolSize", "Cannot be less than zero");
MaxPoolSize
= maxPoolSize;
}

internal object RetrieveFromPool()
{
object result = null;
lock (SyncRoot)
if (Queue.Count > )
result
= Queue.Dequeue();
IPooledResource resultAsIPooledResource
= result as IPooledResource;
if (resultAsIPooledResource != null)
resultAsIPooledResource.RetrievedFromPool();
return result;
}

internal void ReturnToPool(object instance)
{
if (instance == null)
throw new ArgumentNullException("Instance");
IPooledResource instanceAsIPooledResource
= instance as IPooledResource;
if (instanceAsIPooledResource != null)
{
if (!instanceAsIPooledResource.CanReturnToPool)
return;
instanceAsIPooledResource.ReturningToPool();
}
bool wentIntoPool = false;
lock (SyncRoot)
if (Queue.Count < MaxPoolSize)
{
Queue.Enqueue(instance);
wentIntoPool
= true;
}

//Dispose any instances which did not go back into the pool
if (!wentIntoPool && instance is IDisposable)
((IDisposable)instance).Dispose();
}
}

public class PooledLifetimeManagerPoolConsumer :
ContainerControlledLifetimeManager, IDisposable
{
readonly PooledLifetimeManagerPool SharedPool;
object Instance;

internal PooledLifetimeManagerPoolConsumer(
PooledLifetimeManagerPool sharedPool)
{
if (sharedPool == null)
throw new ArgumentNullException("SharedPool");
SharedPool
= sharedPool;
}

protected override object SynchronizedGetValue()
{
if (Instance == null)
Instance
= SharedPool.RetrieveFromPool();
return Instance;
}

protected override void SynchronizedSetValue(object newValue)
{
if (Instance != null && newValue == null)
SharedPool.ReturnToPool(Instance);
Instance
= newValue;
}

public override void RemoveValue()
{
throw new InvalidOperationException();
}

void IDisposable.Dispose()
{
SetValue(
null);
base.Dispose();
}
}
}



//PooledLifetimeStrategy.cs
using Microsoft.Practices.ObjectBuilder;

namespace YourNameHere.Infrastructure.Unity
{
public class PooledLifetimeStrategy : BuilderStrategy
{
public override void PreBuildUp(IBuilderContext context)
{
PooledLifetimeManager activeLifetime
=
context.PersistentPolicies.Get
<ILifetimePolicy>(context.BuildKey)
as PooledLifetimeManager;
if (activeLifetime != null)
{
// did this come from the local container or the parent?
var localLifetime =
context.PersistentPolicies.Get
<ILifetimePolicy>(
context.BuildKey,
true);
if (localLifetime == null)
{
// came from parent, add a ContainerControlledLifetime here
var newLifeTime = activeLifetime.CreatePoolUserForChildContainer();
context.PersistentPolicies.Set
<ILifetimePolicy>(
newLifeTime, context.BuildKey);
//Make sure it gets disposed
//so that it can return its reference to the pool
context.Lifetime.Add(newLifeTime);
}
}
}
}
}



//PooledResourceIntf.cs
namespace YourNameHere.Infrastructure.Unity
{
public interface IPooledResource
{
bool CanReturnToPool { get; }
void RetrievedFromPool();
void ReturningToPool();
}
}

Unity child containers + ASP MVC = Memory leak

Update 2014-12-27 : In later versions of ASP MVC framework you need to implement IAsyncController.EndExecute instead of IController.Execute

I don't tend to do it this way any more, I use the Unity ASP MVC NuGet package.

-----

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
if (controllerType == null) return null; var requestContainer = Container.CreateChildContainer();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


void IController.Execute(RequestContext context) { try { base.Execute(context); } finally { RequestUnityContainer.Dispose(); }


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


protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType) { if (controllerType == null) return null; IUnityContainer requestContainer = Container.CreateChildContainer(); ControllerBase controller = ContainerDisposingControllerFactory.Create(requestContainer, controllerType); return controller; }


The code required is listed below…


//ContainerDisposingControllerIntf.cs using Microsoft.Practices.Unity; namespace YourNameHere.Infrastructure.Web { public interface IContainerDisposingController { IUnityContainer IContainerDisposingController_UnityContainer { get; set; } } } //ContainerDisposingControllerFactory.cs using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using System.Reflection.Emit; using System.Threading; using System.Web.Mvc; using Microsoft.Practices.Unity; namespace YourNameHere.Infrastructure.Web { public static class ContainerDisposingControllerFactory { const string UnityContainerBackingFieldName = "IContainerDisposingController_BackingField"; static MethodInfo DisposeMethodInfo = typeof(IDisposable).GetMethod("Dispose"); static readonly Dictionary<Type, Type> InterceptingType_BySuperClass = new Dictionary<Type, Type>(); static ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(); public static ControllerBase Create(IUnityContainer containerToDispose, Type controllerType) { try { return CreateTypeAndInstance(containerToDispose, controllerType); } catch { containerToDispose.Dispose(); throw; } } private static ControllerBase CreateTypeAndInstance(IUnityContainer containerToDispose, Type controllerType) { Type interceptingControllerType; Locker.EnterUpgradeableReadLock(); try { if (!InterceptingType_BySuperClass.TryGetValue(controllerType, out interceptingControllerType)) { Locker.EnterWriteLock(); try { interceptingControllerType = CreateInterceptingControllerType(controllerType); InterceptingType_BySuperClass[controllerType] = interceptingControllerType; } finally { Locker.ExitWriteLock(); } } } finally { Locker.ExitUpgradeableReadLock(); } var result = (Controller)containerToDispose.Resolve(interceptingControllerType); var resultAsIUnityContainerController = (IContainerDisposingController)result; resultAsIUnityContainerController.IContainerDisposingController_UnityContainer = containerToDispose; return result; } static Type CreateInterceptingControllerType(Type controllerType) { if (!typeof(ControllerBase).IsAssignableFrom(controllerType)) throw new ArgumentException("ControllerType does not descend from ControllerBase"); string guid = Guid.NewGuid().ToString(); var assemblyName = new AssemblyName(guid); var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run); var moduleBuilder = assemblyBuilder.DefineDynamicModule(guid); var typeBuilder = moduleBuilder.DefineType( guid, TypeAttributes.Class | TypeAttributes.Public, controllerType); CreateConstructor(controllerType, typeBuilder); FieldBuilder unityContainerBackingFieldBuilder; ImplementIContainerDisposingController(typeBuilder, out unityContainerBackingFieldBuilder); ImplementIController(controllerType, typeBuilder, unityContainerBackingFieldBuilder); return typeBuilder.CreateType(); } static void CreateConstructor(Type controllerType, TypeBuilder typeBuilder) { var constructorInfo = controllerType.GetConstructors() .OrderByDescending(x => x.GetParameters().Count()) .FirstOrDefault(); if (constructorInfo == null) return; ParameterInfo[] constructorParameters = constructorInfo.GetParameters().ToArray(); Type[] parameterTypes = constructorParameters.Select(x => x.ParameterType).ToArray(); var constructorBuilder = typeBuilder.DefineConstructor( MethodAttributes.Public, CallingConventions.Standard, parameterTypes); //Define the parameters for our new constructor for (int argumentIndex = ; argumentIndex < parameterTypes.Length; argumentIndex++) constructorBuilder.DefineParameter( argumentIndex + , constructorParameters[argumentIndex].Attributes, constructorParameters[argumentIndex].Name); var bodyGenerator = constructorBuilder.GetILGenerator(); bodyGenerator.Emit(OpCodes.Ldarg_); for (int argumentIndex = ; argumentIndex < parameterTypes.Length; argumentIndex++) bodyGenerator.Emit(OpCodes.Ldarg_S, argumentIndex + ); bodyGenerator.Emit(OpCodes.Call, constructorInfo); bodyGenerator.Emit(OpCodes.Ret); } static void ImplementIContainerDisposingController(TypeBuilder typeBuilder, out FieldBuilder unityContainerBackingFieldBuilder) { typeBuilder.AddInterfaceImplementation(typeof(IContainerDisposingController)); unityContainerBackingFieldBuilder = typeBuilder.DefineField( UnityContainerBackingFieldName, typeof(IUnityContainer), FieldAttributes.Private); var propertyAccessorAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual; var getterBuilder = typeBuilder.DefineMethod( "get_IContainerDisposingController_UnityContainer", propertyAccessorAttributes, typeof(IUnityContainer), Type.EmptyTypes); var getterGenerator = getterBuilder.GetILGenerator(); getterGenerator.Emit(OpCodes.Ldarg_); getterGenerator.Emit(OpCodes.Ldfld, unityContainerBackingFieldBuilder); getterGenerator.Emit(OpCodes.Ret); var setterBuilder = typeBuilder.DefineMethod( "set_IContainerDisposingController_UnityContainer", propertyAccessorAttributes, null, new Type[] { typeof(IUnityContainer) }); var setterGenerator = setterBuilder.GetILGenerator(); setterGenerator.Emit(OpCodes.Ldarg_); setterGenerator.Emit(OpCodes.Ldarg_); setterGenerator.Emit(OpCodes.Stfld, unityContainerBackingFieldBuilder); setterGenerator.Emit(OpCodes.Ret); } static void ImplementIController(Type controllerType, TypeBuilder typeBuilder, FieldBuilder unityContainerBackingFieldBuilder) { typeBuilder.AddInterfaceImplementation(typeof(IController)); MethodInfo baseMethod = null; Type implementingType = controllerType; do { baseMethod = implementingType.GetMethod( "Execute", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); implementingType = implementingType.BaseType; } while (baseMethod == null && implementingType != null); if (baseMethod == null) throw new NotImplementedException(controllerType.Name + " does not implement IController.Execute"); var methodParameters = baseMethod.GetParameters(); var methodBuilder = typeBuilder.DefineMethod( typeof(IController).Name + ".Execute", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.ReuseSlot | MethodAttributes.HideBySig, null, methodParameters.Select(x => x.ParameterType).ToArray()); //Define the parameters for our new constructor for (int argumentIndex = ; argumentIndex < methodParameters.Length; argumentIndex++) methodBuilder.DefineParameter( argumentIndex + , methodParameters[argumentIndex].Attributes, methodParameters[argumentIndex].Name); var bodyGenerator = methodBuilder.GetILGenerator(); bodyGenerator.BeginExceptionBlock(); bodyGenerator.Emit(OpCodes.Ldarg_); for (int argumentIndex = ; argumentIndex < methodParameters.Length; argumentIndex++) bodyGenerator.Emit(OpCodes.Ldarg_S, argumentIndex + ); bodyGenerator.Emit(OpCodes.Call, baseMethod); bodyGenerator.BeginFinallyBlock(); bodyGenerator.Emit(OpCodes.Ldarg_); bodyGenerator.Emit(OpCodes.Ldfld, unityContainerBackingFieldBuilder); bodyGenerator.Emit(OpCodes.Call, DisposeMethodInfo); bodyGenerator.EndExceptionBlock(); bodyGenerator.Emit(OpCodes.Ret); typeBuilder.DefineMethodOverride(methodBuilder, baseMethod); } } }

ECO atomic operations

I’ve just created a simple class which I thought I’d share.

Account1.Balance += 10;
Account2.Balance
-= 10;


In this case we might expect the second line to throw an exception if the adjustment is not permitted, but the first line has already executed.  Obviously this isn’t a problem because we simply wouldn’t update the database, but sometimes you want an operation to occur in memory as an atomic operation; like this



using (var atomicOperation = new AtomicOperation(EcoSpace))
{
Account1.Balance
+= 10;
Account2.Balance
-= 10;
atomicOperation.Commit();
}


And so that is exactly what I wrote.  The class uses the UndoService to create/merge/remove undo blocks so it is even possible to nest atomic operations.



public class AtomicOperation
{
readonly IEcoServiceProvider EcoServiceProvider;
readonly IUndoService UndoService;
readonly IUnitOfWorkValidator UnitOfWorkValidator;
bool IsActive;
string UndoBlockName;

public AtomicOperation(IUnitOfWork unitOfWork, IUnitOfWorkValidator unitOfWorkValidator)
{
if (unitOfWork == null)
throw new ArgumentNullException("UnitOfWork");
if (unitOfWorkValidator == null)
throw new ArgumentNullException("UnitOfWorkValidator");

this.UndoBlockName = Guid.NewGuid().ToString();
this.EcoServiceProvider = unitOfWork.ObjectSpace;
this.UndoService = EcoServiceProvider.Resolve<IUndoService>();
this.UnitOfWorkValidator = unitOfWorkValidator;
this.UndoService.StartUndoBlock(this.UndoBlockName);
this.IsActive = true;
}

public bool Commit(List<ValidationError> validationErrors, IEcoObject rootObjectToValidate, PathStack currentPath = null)
{
if (validationErrors == null)
throw new ArgumentNullException("ValidationErrors");
if (currentPath == null)
throw new ArgumentNullException("CurrentPath");

int index = UndoService.UndoList.IndexOf(UndoBlockName);
if (index == -1)
throw new InvalidOperationException("Undo block not found");
EnsureIsLatestAtomicOperation();

IUndoBlock undoBlock
= UndoService.UndoList[index];
if (rootObjectToValidate != null)
UnitOfWorkValidator.EnsureObjectIsValidated(rootObjectToValidate);

var newErrors
= new List<ValidationError>();
newErrors.AddRange(UnitOfWorkValidator.Validate(
this, currentPath));
validationErrors.AddRange(newErrors);

if (index > 0)
{
string nameOfBlockAbove = UndoService.UndoList[index - 1].Name;
UndoService.UndoList.MergeBlocks(nameOfBlockAbove, UndoBlockName);
}
RemoveUndoBlocks();

IsActive
= false;
return newErrors.Count == 0;
}

public void RollBack()
{
if (!IsActive)
throw new InvalidOperationException("AtomicOperation has already been committed or rolled back");

IUndoBlock undoBlock
= UndoService.UndoList[UndoBlockName];
if (undoBlock == null)
throw new InvalidOperationException("Undo block not found");

UndoService.UndoBlock(UndoBlockName);
RemoveUndoBlocks();
IsActive
= false;
}

void IDisposable.Dispose()
{
GC.SuppressFinalize(
this);
if (IsActive)
RollBack();
}

~AtomicOperation()
{
throw new InvalidOperationException("AtomicOperation was not disposed");
}

public IEnumerable<Eco.ObjectRepresentation.IObject> GetModifiedObjects()
{
var undoBlock
= UndoService.UndoList[UndoBlockName];
Eco.ObjectRepresentation.IObjectList result
= undoBlock.GetChangedObjects();
Contract.Assume(result
!= null);
return result;
}

void RemoveUndoBlocks()
{
if (UndoService.UndoList.IndexOf(UndoBlockName) > -1)
UndoService.UndoList.RemoveBlock(UndoBlockName);
if (UndoService.RedoList.IndexOf(UndoBlockName) > -1)
UndoService.RedoList.RemoveBlock(UndoBlockName);
}

void EnsureIsLatestAtomicOperation()
{
int undoBlockIndex = UndoService.UndoList.IndexOf(UndoBlockName);
if (undoBlockIndex != -1 && undoBlockIndex != UndoService.UndoList.Count - 1)
throw new InvalidOperationException("AtomicOperation contains child atomic operations");
}
}
}

ASP MVC CheckListBox

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;
}
}
}

Unity.BuildUp–Ambiguous constructor

Sometimes you have no control over the instantiation of your classes and therefore cannot use Unity. For this reason the BuildUp method was added to Unity in order to either call the method marked with [InjectionMethod] or to set all properties marked with [Dependency].  Unfortunately in the latest build this is broken.  For some reason BuildUp searches for a suitable constructor even though the instance has already been created.  In my case I have two constructors both with only 1 parameter so I get an ambiguous constructor exception.

So, I created this helper method to call the InjectionMethod on the instance…

public static class UnityContainerHelper
{
public static void CallInjectionMethod(this IUnityContainer unityContainer, object instance, params ResolverOverride[] overrides)
{
if (instance == null)
throw new ArgumentNullException("Instance");

var injectionMethodInfo
= instance.GetType().GetMethods().Where(x => x.GetCustomAttributes(typeof(InjectionMethodAttribute), true).Any()).SingleOrDefault();
if (injectionMethodInfo == null)
return;
var parameters
= injectionMethodInfo.GetParameters();
if (parameters.Length == 0)
return;

var dependencies
= new object[parameters.Length];
int index = 0;
foreach (Type parameterType in parameters.Select(x => x.ParameterType))
{
dependencies[index]
= unityContainer.Resolve(parameterType, overrides);
index
++;
}
injectionMethodInfo.Invoke(instance, dependencies);
}
}