Each new term in the Fibonacci sequence is generated by
adding the previous two terms. By starting with 1 and 2, the first
10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …
By considering the terms in the Fibonacci sequence whose
values do not exceed four million, find the sum of the even
valued terms.

Challenge here is to generate a fibonacci sequence, which is the fib(n-1) + fib(n-2) formula. This generates a evaluation tree during recursion and becomes quite large when generating a large N fibonacci value, and stackoverflow happens. To tackle this problem in a more efficient way, we shouldn’t generate the number for N re-cursing backwards, but generate the number from summation forwards.

Here’s my first F# solution I came up with.

let initiniteFib =
    let rec fib1 n1 n2 =
        seq {
            yield n1
            yield! fib1 n2 (n1+n2)
        }
    fib1 0I 1I

let answer = initiniteFib 
                |> Seq.takeWhile (fun x -> x < 4000000I)
                |> Seq.filter (fun x -> x % 2I = 0I)
                |> Seq.sum

Another way to solve the same problem, is using Seq.unfold.

let answer = Seq.unfold (fun (first, second) -> Some(second, (second, first+second))) (0I, 1I)
                |> Seq.takeWhile (fun x-> x < 4000000I)
                |> Seq.filter (fun x -> x % 2I = 0I)
                |> Seq.sum

If you have more interesting ways to solve this, please share.

I’ve gotten much more confidence now writing in F#, and starting to actually enjoy it more than C#. It’s a very different mindset and paradigm to write functionally.

We’ve also started a small community at work learning, sharing and practicing in F#. One of the interesting exercises is solving mathematical problems in F# from Project Euler.

Here’s my solution in solving Problem 1.

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.

let answer = seq {1..999}
|> Seq.filter (fun n -> n % 3 = 0 || n % 5 = 0)
|> Seq.sum

Simple enough

A very common retry logic I’ve seen to implement the retry logic is using a while loop to enforce the maximum number of retries, and a Thread.Sleep to perform the wait time. This is an example below.

public class Calculate
{
    private readonly Calculator _calculator;

    public Calculate(Calculator calculator)
    {
        _calculator = calculator;
    }

    public int CalculateWithRetry()
    {
        const int maxRetryAttemps = 2;
        int retryAttempts = 0;
        while (retryAttempts <= maxRetryAttemps)
        {
            try
            {
                return _calculator.Calculate();
            }
            catch (InvalidOperationException)
            {
                retryAttempts++;
                Thread.Sleep(TimeSpan.FromSeconds(2));
            }
        }
        return 0;
    }
}

There is absolutely nothing wrong with doing that in my opinion, it’s straightforward and the simplest implementation I can think of.

I thought to myself though, if there is another way to write a retry task. I explored different opinions, and found one option to be both interesting and intriguing. I decided to try and implement the retry logic using the Task Parallelism Library (TPL) in .NET Framework 4.5.

I created a generic RetryTask, that is able to take in an Action as well as a Func<T> as retry-able actions, first being a void and other returning a result. The RetryTask also takes in a generic TException, which triggers the retry when that exception is being thrown. For instance, you can create a RetryTask with a CommunicationException, so in the event of timeouts, the web service request can be retried.

public class RetryTask : IRetryTask
{
    private readonly ILogger _logger;
    private int _retryWaitIntervalSeconds;
    private int _retryAttempts;

    public RetryTask() : this(new ConsoleLogger())
    {}

    public RetryTask(ILogger logger)
    {
        _logger = logger;
    }

    public bool Execute<TException>(Action action, int retryWaitIntervalSeconds, int retryAttempts)
        where TException : Exception
    {
        _retryWaitIntervalSeconds = retryWaitIntervalSeconds;
        _retryAttempts = retryAttempts;
        int result;
        Func<int> actionFuncWrapper = () =>
            {
                action();
                return 0;
            };
        return StartTaskWithRetryRecursive<int, TException>(actionFuncWrapper, out result);
    }

    public bool Execute<TResult, TException>(Func<TResult> action, int retryWaitIntervalSeconds, int retryAttempts, out TResult result)
        where TException : Exception
    {
        _retryWaitIntervalSeconds = retryWaitIntervalSeconds;
        _retryAttempts = retryAttempts;
        return StartTaskWithRetryRecursive<TResult, TException>(action, out result);
    }

    private bool StartTaskWithRetryRecursive<TResult, TException>(Func<TResult> action, out TResult result, int retryAttemptNumber = 1)
        where TException : Exception
    {
        result = default(TResult);

        var taskCompletionSource = new TaskCompletionSource<bool>();

        Task<TResult> task = StartNewTask<TResult, TException>(action, taskCompletionSource);

        WaitForTaskCompletion(taskCompletionSource);
        if (taskCompletionSource.Task.Result) 
        {
            result = task.Result;
            return true;
        }

        StartDelay(retryAttemptNumber);
        if (retryAttemptNumber <= _retryAttempts)
            return StartTaskWithRetryRecursive<TResult, TException>(action, out result, retryAttemptNumber + 1);

        return false;
    }

    private void WaitForTaskCompletion(TaskCompletionSource<bool> taskCompletionSource) 
    {
        try 
        {
            taskCompletionSource.Task.Wait();
        } 
        catch (AggregateException ex) 
        {
            _logger.Error("unexpected error encountered whilst invoking action, {0}", ex.ToString());
            throw;
        }
    }

    private void StartDelay(int attemptNumber) 
    {
        _logger.Info("attempting retry number {0} after delay of {1} seconds...", attemptNumber, _retryWaitIntervalSeconds);
        Task.Delay(TimeSpan.FromSeconds(_retryWaitIntervalSeconds)).Wait();
    }

    private Task<TResult> StartNewTask<TResult, TException>(Func<TResult> action, TaskCompletionSource<bool> taskCompletionSource)
        where TException : Exception
    {
        Func<object, TResult> taskFunc = obj => action();  
        var startTask = new Task<TResult>(taskFunc, taskCompletionSource);

        // creates two mutually exclusive continuation tasks, one that will only run if startTask is successful, and another that will run if startTaskFails.
        startTask.ContinueWith<TResult>(ContinueWithOnCompletionTask, taskCompletionSource, TaskContinuationOptions.OnlyOnRanToCompletion);
        startTask.ContinueWith<TResult>(ContinueWithOnFaultedTask<TResult, TException>, taskCompletionSource, TaskContinuationOptions.OnlyOnFaulted);

        startTask.Start();
        return startTask;
    }

    private TResult ContinueWithOnFaultedTask<TResult, TException>(Task<TResult> antecedantTask, object taskCompletionSource) 
        where TException : Exception
    {
        if (antecedantTask.Exception != null)
        {
            if (antecedantTask.Exception.InnerException.GetType() == typeof(TException)) 
            {
                _logger.Warning("{0} exception occurred: {1}", typeof(TException).Name, antecedantTask.Exception.InnerException.ToString());
                ((TaskCompletionSource<bool>)taskCompletionSource).SetResult(false); // signal that a TException error occurred and we should retry
            } 
            else
            {
                ((TaskCompletionSource<bool>)taskCompletionSource).SetException(antecedantTask.Exception);
            }
        }
        return default(TResult);
    }

    private TResult ContinueWithOnCompletionTask<TResult>(Task<TResult> antecedantTask, object taskCompletionSource) 
    {
        ((TaskCompletionSource<bool>)taskCompletionSource).SetResult(true); // signals all went well
        return antecedantTask.Result;
    }
}

Comparatively, the RetryTask is far more complex and also harder to read for someone who’s unfamiliar with the TPL. For myself, this is a more of a learning exercise; Also I’m not a big fan of using while loops and Thread.Sleep in production code, and using TPL is an alternative.

Some of the TPL functions used in the RetryTask are:

• TaskCompletionSource
• Task.ContinueWith
• TaskContinuationOptions (See OnlyRanToCompletion and OnlyOnFaulted)
• Task.Delay

The source code can be found in EdLib.

Let me know how you would implement a Retry implementation

This is my version on how to create a custom formatter factory that understand custom formats we create, and routes to the appropriate formatter. If a non-custom format is used, the conversion will still be performed as normal. In the example, I’m trying to create custom formats “bsb” and “acctno” which will convert numbers to a “999-999” format and “1234-56789” format using the CustomFormatProvider.

Here is my CustomFormatProvider class.

public class CustomFormatProvider : IFormatProvider, ICustomFormatter
{
    private readonly IStringFormatterFactory _stringFormatterFactory;

    public CustomFormatProvider() : this(new StringFormatterFactory())
    {
    }

    public CustomFormatProvider(IStringFormatterFactory stringFormatterFactory)
    {
        _stringFormatterFactory = stringFormatterFactory;
    }

    public object GetFormat(Type formatType)
    {
        if (formatType == typeof(ICustomFormatter))
            return this;
        return null;
    }

    public string Format(string format, object arg, IFormatProvider formatProvider)
    {
        IStringFormatter stringFormatter = _stringFormatterFactory.GetFormatter(format);
        return stringFormatter.Format(arg, format);
    }
}

Here is my StringFormatterFactory

public class StringFormatterFactory : IStringFormatterFactory
{
    public IStringFormatter GetFormatter(string format)
    {
        if (format == CustomStringFormat.Bsb)
            return new BsbStringFormatter();

        if (format == CustomStringFormat.AccountNumber)
            return new AccountNumberStringFormatter();

        return new DefaultStringFormatter();
    }
}

Now here are my StringFormatter implementations for bsb and acctno, and a default one.

public class BsbStringFormatter : IStringFormatter
{
    private const string ValidFormat = "^[0-9]{6}$";

    public string Format(object arg, string format)
    {
        string input = arg.ToString();
        if (Regex.IsMatch(input, ValidFormat))
        {
            return string.Format("{0}-{1}", input.Substring(0, 3), input.Substring(3, 3));
        }
        throw new FormatException(
            string.Format("unable to format input value {0} to {1} format", input, format));
    }
}

public class AccountNumberStringFormatter : IStringFormatter
{
    private const string ValidFormat = "^[0-9]{9}$";

    public string Format(object arg, string format) {
        string input = arg.ToString();
        if (Regex.IsMatch(input, ValidFormat)) {
            return string.Format("{0}-{1}", input.Substring(0, 5), input.Substring(5, 4));
        }
        throw new FormatException(
            string.Format("unable to format input value {0} to {1} format", input, format));
    }
}

public class DefaultStringFormatter : IStringFormatter
{
    public string Format(object arg, string format)
    {
        if (arg is IFormattable)
            return ((IFormattable)arg).ToString(format, CultureInfo.CurrentCulture);

        if (arg != null)
            return arg.ToString();

        return String.Empty;
    }
}

Now this is how one would use the CustomFormatProvider

var customFormatProvider = new CustomFormatProvider();

string message =
    string.Format(customFormatProvider, "BSB:{0:bsb}, ACCT:{1:acctno}, BALANCE:{2:C2}", "013987", "123456789", 450.22);
// will display "BSB:013-987, ACCT:12345-6789, BALANCE:$450.22"

Download code sample here.

Consider this XML.

<?xml version="1.0" encoding="utf-8" ?>
<Order>
 <Product id="1" name="Nexus 5">
 <Price>400.00</Price>
 <Qty>1</Qty>
 </Product>
 <Product id="5" name="Wireless Charger">
 <Price>50.00</Price>
 <Qty>1</Qty>
 </Product>
</Order>

This would have been typically how I would dig into the XML to find certain data using XDocument, in a safe way of course.

public string FindPriceForProduct(XDocument xDoc, string productName)
{
    XElement orderElement = xDoc.Element("Order");
    if (orderElement != null)
    {
        XElement productElement = orderElement.Elements("Product")
                                .FirstOrDefault(product=> product.Attribute("name") != null
                                            && product.Attribute("name").Value == productName);
        if (productElement != null)
        {
            XElement priceElement = productElement.Element("Price");
            return priceElement != null ? priceElement.Value : string.Empty;
        }
    }
    return string.Empty;
}

public decimal FindTotalCost(XDocument xDoc)
{
    XElement orderElement = xDoc.Element("Order");
    if (orderElement != null)
    {
        IEnumerable productPrices = orderElement.Elements("Product")
                                        .SelectMany(product => product.Elements("Price"))
                                        .Select(price => decimal.Parse(price.Value));
        return productPrices.Sum();
    }
    return 0;
}

As you can see from the code above, it’s defensive and unsightly, even with the Linq extensions. With XPath Extensions, all you need is to add using System.Xml.XPath and new extension methods will be available on XDocument object. Let’s rewrite the code above with XPath Extensions.

using System;
using System.Xml.Linq;
using System.Xml.XPath;

public string FindPriceForProduct(XDocument xDoc, string productName)
{
    string xpath = string.Format("/Order/Product[@name='{0}']/Price", productName);
    XElement productElement = xDoc.XPathSelectElement(xpath);
    return productElement != null ? productElement.Value : string.Empty;
}

public decimal FindTotalCost(XDocument xDoc)
{
    object prices = xDoc.XPathEvaluate("sum(/Order//Product/Price/text())");
    return prices != null ? Convert.ToDecimal(prices) : 0;
}

This new code is much neater, and there isn’t any need to check for nulls. If any part of the xpath expression has invalid nodes, the result will be null. There is only one method call, and not to mention the cool XPath conditions and functions you can use with the extension method. This greatly simplifies unnecessary complexity with code.

Here are some XPath examples you can use. Enjoy.

Here’s some code to do it.

const int fiftyMillionsLines = 50000000;
using (var fileStream = File.CreateText(@"C:\temp\large.csv"))
{
    for (int i = 1; i <= fiftyMillionsLines; i++)          {                   fileStream.WriteLine("line {0}", i);          }          fileStream.Close();  }  

I have 16GB of physical memory on my machine, so 50 millions lines was the breaking point for me. You can adjust that to create a csv large enough that will break String.Split. Next here’s a simple NUnit test that will illustrate the exception being thrown using the file we generated.

  [Test]  public void StringSplit_ForLargeCsv_WillThrowOutOfMemoryException()  {          var fileContents = File.ReadAllText(@"C:\temp\large.csv");         Assert.Throws(() => fileContents.Split(new[] {"\r\n", "\n"}, StringSplitOptions.RemoveEmptyEntries));
}

Obviously, some form of processing is required for each line you split, and it seems somewhat inefficient to get a collection of split lines upfront. Instead, it would seem more pragmatic to yield each line and perform processing one line at a time. A StringReader would seem fit for that purpose. Here’s a LineSplitter class I created to replace the use of String.Split.

public class LineSplitter : ILineSplitter
{
    protected readonly string[] RowDelimiter = new[] { "\r\n", "\n" };

    public IEnumerable SplitYield(string input)
    {
        using (var stringReader = new StringReader(input))
        {
            int rowIndex = 0;
            string rowString;
            while (!string.IsNullOrEmpty(rowString = stringReader.ReadLine()))
            {
                rowIndex++;
                yield return new StringLine(rowString, rowIndex);
            }
            stringReader.Close();
        }
    }
}

public class StringLine
{
    internal StringLine(string line, int rowIndex)
    {
        Value = line;
        RowIndex = rowIndex;
    }

    public string Value { get; private set; }

    public int RowIndex { get; private set; }
}

Using the same csv file generated, we can now run a test against that using LineSplitter.

[Test]
public void UsingLineSplitter_ForLargeCsv_WillNotThrowOutOfMemoryException()
{
    var fileContents = File.ReadAllText(@"C:\temp\large.csv");

    var lineSplitter = new LineSplitter();
    Assert.DoesNotThrow(()=>lineSplitter.SplitYield(fileContents)
        .Select(stringLine => stringLine.Value).ToList());
}

That test passes, and all contents of the large csv can be loaded into memory without memory exception.

LineSplitter code can be found @ EdLib.

public class FileLoader
{
    private readonly StreamReader _streamReader;

    public FileLoader(StreamReader streamReader)
    {
        _streamReader = streamReader;
    }

    public IEnumerable<string> Read()
    {
        var output = new List<string>();
        string line;
        while (!string.IsNullOrEmpty(line = _streamReader.ReadLine()))
        {
            output.Add(line);
        }
        _streamReader.Close();
        _streamReader.Dispose();
        return output;
    }
}

The problem I have with this class is that it isn’t exactly unit testable. First of all, it uses a stream reader and it’s not straightforward to be able to mock a stream reader due to the lack of an interface. Secondly what I reckon most developers would do is pass a real stream reader into the class and write tests in that fashion, which would be more of an integration test.

Personally that is not proper unit testing as the class dependencies are not mocked. It is somewhat unavoidable we would be using un-mockable classes from the .NET framework, such as ConfigurationManager, Environment.GetVariable, etc.

The way I would solve this problem is create an interface for StreamReader, so I can mock it. As for the concrete implementation, I would create a wrapper class for StreamReader which implements that interface. So that makes my class unit testable like so.

public interface IStreamReader
{
    string ReadLine();
    void Close();
    void Dispose();
}

public class FileLoader
{
    private readonly IStreamReader _streamReader;

    public FileLoader(IStreamReader streamReader)
    {
        _streamReader = streamReader;
    }

    public IEnumerable<string> Read()
    {
        var output = new List<string>();
        string line;
        while (!string.IsNullOrEmpty(line = _streamReader.ReadLine()))
        {
            output.Add(line);
        }
        _streamReader.Close();
        _streamReader.Dispose();
        return output;
    }
}

Is this too extreme? I would actually write wrappers for many un-mockable classes so I can unit test them. This brings me another unfortunate side-effect, which is I end up writing lots of wrapper classes. This is not ideal, so I came up with an ObjectProxy which could create a proxy object that implements an interface I specify and delegate interface calls to the real object. Referencing the StreamReader example, I would create an IStreamReader like so.

public IEnumerable<string> ReadFile()
{
    var streamReader = new StreamReader(@"C:\somefile.txt");
    var fileLoader = new FileLoader(ObjectProxy<IStreamReader>.Create(streamReader));
    return fileLoader.Read();
}

There are other ways to achieve the same result. For instance, I believe you could use Castle DynamicProxy libaries, or using .NET Reflection Emit. My approach is just simply another method, and one I prefer over the others. Here’s the ObjectProxy.

using System;
using System.Reflection;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;

namespace EdLib.Objects.Proxy
{
    public class ObjectProxy<TInterface> : RealProxy where TInterface : class
    {
        private readonly object _instance;

        private ObjectProxy(object instance) : base(typeof(TInterface))
        {
            _instance = instance;
        }

        public static TInterface Create(object instance)
        {
            return (TInterface)new ObjectProxy<TInterface>(instance).GetTransparentProxy();
        }

        public override IMessage Invoke(IMessage msg)
        {
            var methodCall = (IMethodCallMessage)msg;
            var method = (MethodInfo)methodCall.MethodBase;

            try
            {
                var returnValue = TryInvokeMethodFromRealInstance(methodCall, method);
                return new ReturnMessage(returnValue, null, 0, methodCall.LogicalCallContext, methodCall);
            }
            catch (Exception ex)
            {
                if (ex is TargetInvocationException && ex.InnerException != null)
                {
                    return new ReturnMessage(ex.InnerException, methodCall);
                }
                return new ReturnMessage(ex, methodCall);
            }
        }

        private object TryInvokeMethodFromRealInstance(IMethodCallMessage methodCall, MethodInfo methodInfo)
        {
            var instanceMethodInfo = _instance.GetType().GetMethod(methodInfo.Name);
            if (instanceMethodInfo != null)
            {
                return instanceMethodInfo.Invoke(_instance, methodCall.InArgs);
            }
            throw new Exception(string.Format("unable to find method {0} from real instance", methodInfo.Name));
        }
    }
}

This can also be from in EdLib @ Github, my code library.

I’ve decided to do exactly that. I’ve created a personal library where I want to store useful, reusable code that helps me in my everyday work, and hopefully will be useful to others too. Coming up with a name was hard, so I’ve decide to concatenate my name and the work “Lib” together, which becomes EdLib.

For the first addition, I’ve decided to solve a common problem all of us would have encountered at some point. For instance, you have to access a property that’s nested, and you end up writing many ifs to check for null, like so

if (person != null)
{
    if (person.Membership != null)
    {
        if (person.Membership.Account != null)
        {
            return person.Membership.Account.AccountNumber;
        }
    }
}
return 0;

It sucks to have to write code like that, and would be great to be able to compress that into a single line, evaluate if the account number can be retrieved otherwise return 0.

I’ve used Expression to achieve that. I’ve added extension methods for getting and setting nested property values using Expressions.

public static bool TrySetValue<T, TResult>(this T instance, Expression<Func<T, TResult>> expression, TResult value) where T : class

public static void SetValue<T, TResult>(this T instance, Expression<Func<T, TResult>> expression, TResult value) where T : class

public static TResult GetValueOrDefault<T, TResult>(this T instance, Expression<Func<T, TResult>> expression) where T : class

public static TResult GetValue<T, TResult>(this T instance, Expression<Func<T, TResult>> expression) where T : class

GetValueOrDefault will evaluate the expression; if any of nested object references are null, the default value will be returned.
GetValue will evaluate the expression; if any of the nested object references are null, an exception will be thrown.
SetValue will set the value for the expression; if it cannot evaluate the expression, an exception will be thrown.
TrySetValue will set the value for the expression, if it cannot evaluate the expression, it returns false.

Usage of the GetValueOrDefault extension method would vastly simplify the nested if code snippet above, like so…

return person.GetValueOrDefault(x=>x.Membership.Account.AccountNumber);

You can get the source and unit tests for this @ Github.

Example 1: simple loop through strings to print to console

public void PrintStrings(IEnumerable inputs)
{
    foreach (var input in inputs)
    {
        Console.WriteLine(input);
    }
}

public void PrintStringsLinq(IEnumerable inputs)
{
    inputs.ToList().ForEach(Console.WriteLine);
}

Example 2: Only print string if condition is matched

public void PrintStrings(IEnumerable inputs)
{
    foreach (var input in inputs)
    {
        if (input.Contains("some string"))
        {
            Console.WriteLine(input);
        }
    }
}

public void PrintStringsLinq(IEnumerable inputs)
{
   inputs.Where(input=>input.Contains("some string")).ToList().ForEach(Console.WriteLine);
}

Example 3: Break printing loop if a condition is met

public void PrintStrings(IEnumerable inputs)
{
    foreach (var input in inputs)
    {
        if (!input.Contains("some string"))
        {
            break;
        }
        Console.WriteLine(input);
    }
}

public void PrintStringsLinq(IEnumerable inputs)
{
    inputs.TakeWhile(input => input.Contains("some string")).ToList().ForEach(Console.WriteLine);
}

Example 4: Make a list of strings comma separated

public void PrintStrings(IEnumerable inputs)
{
    var inputList = inputs.ToList();
    var output = string.Empty;
    for (var index = 0; index < inputList.Count; index++)
    {
        if (index == 0)
            output = inputList[index];
        else
            output = string.Format("{0},{1}", output, inputList[index]);
    }
    Console.WriteLine(output);
}

public void PrintStringsLinq(IEnumerable inputs)
{
    var output = inputs.Aggregate((first, second) => string.Format("{0},{1}", first, second));
    Console.WriteLine(output);
}

Example 5: Converting list of strings to XElements

public IEnumerable GetXElements(IEnumerable inputs)
{
    var xElements = new List();
    foreach (var input in inputs)
    {
        xElements.Add(new XElement(new XElement(input)));
    }
    return xElements;
}

public IEnumerable GetXElementsLinq(IEnumerable inputs)
{
    return inputs.Select(input => new XElement(input));
}

Example 6: Printing list of objects within a list of objects

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

public class Basket
{
    public IEnumerable Fruits { get; set; }
}

public void PrintFruits(IEnumerable baskets)
{
    foreach (var basket in baskets)
    {
        foreach (var fruit in basket.Fruits)
        {
            Console.WriteLine(fruit.Name);
        }
    }
}

public void PrintFruitsLinq(IEnumerable baskets)
{
    baskets.SelectMany(x=>x.Fruits).ToList().ForEach(fruit => Console.WriteLine(fruit.Name));
}

Linq is capable of much more than the examples above but I find these are the common usages in my day to day coding. I do hope you will explore Linq more and unravel the power within in your code.

Anyways we use Castle Windsor on our project, but in theory we should be able to use any IoC framework.  I started to think about how to decouple the project from a specific IoC framework, so if we ever wanted to change to a different one, it would be easy and straightforward. Perhaps this is overkill in the real world, but would be a good exercise to go through.

For this example, I’ve decided to use Castle Windsor and Unity, both of which I’m pretty familiar with. The idea behind this is to create an interface library on which the Castle and Unity libraries will implement, essentially a plug-in mechanism.

Here is the interface for IContainer, essentially a contract for the IoC Container we will be utilizing.

public interface IContainer : IRegister, IResolve, IDisposable
{
}

public interface IResolve
{
    T Resolve<T>();

    T Resolve<T>(string key);

    bool CanResolve<T>();

    bool CanResolve<T>(string key);

    void Release(object instance);
}

public interface IRegister
{
    IRegister Register<TInterface, TClass>(Lifetime lifetime)
        where TInterface : class
        where TClass : TInterface;

    IRegister Register<TInterface, TClass>(string key, Lifetime lifetime)
        where TInterface : class
        where TClass : TInterface;

    IRegister RegisterAllClassesBasedOn<TInterface>(Lifetime lifetime) where TInterface : class;
}

There’s also an interface for IInstaller, which is a contract for installing or registering your components. This is based on the installer concept in Castle Windsor which I find useful.

public interface IInstaller
{
    void Install(IContainer container);
}

Lastly there’s a IoC static class which allows you to register your selected IoC implementation based on the specification from a configuration section, like so.

<configSections>
    <section name="iocConfiguration" type="IoC.IocConfiguration, IoC"/>
</configSections>

<iocConfiguration assemblyName="Unity" />

public static class Ioc
{
    public static IContainer Initialize(IInstaller installer)
    {
        var assemblyWithLocation = GetAssemblyNameWithLocation();
        var assembly = Assembly.LoadFrom(assemblyWithLocation);

        var containerType =
            assembly.GetTypes().Single(x => x.GetInterface(typeof(IContainer).FullName) != null);
        var container = (IContainer)Activator.CreateInstance(containerType);
        installer.Install(container);
        return container;
    }

    private static string GetAssemblyNameWithLocation()
    {
        var location = Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase);
        var assemblyNameWithLocation = Path.Combine(location, GetAssemblyName()).Replace("file:\\", "");

        if (!File.Exists(assemblyNameWithLocation))
            throw new FileNotFoundException("unable to find assembly");
        return assemblyNameWithLocation;
    }

    private static string GetAssemblyName()
    {
        return string.Format("{0}.dll", IocConfiguration.Settings.AssemblyName);
    }
}

You just have to specify the name of the assembly you want to plug in. You also have to ensure that the assembly is present in the folder containing your executing assembly, I achieved this using a post build event.

As for the implementation details of Castle and Unity, I won’t be going into details. You can download the sample to have a look if interested. In the MVC application, I’ve created an Installer to register the HomeController. If there are other dependencies you need, register them here.

public class Installer : IInstaller
{
    public void Install(IContainer container)
    {
        container.Register<IController, HomeController>("Home", Lifetime.Transient);
    }
}

Next I create a ControllerFactory that uses our IContainer to register dependencies, instead of the default one from MVC.

public class ControllerFactory : IControllerFactory
{
    private readonly IContainer _container;
    private readonly IControllerFactory _defaultControllerFactory;

    public ControllerFactory(IContainer container) : this(container, new DefaultControllerFactory())
    {}

    public ControllerFactory(IContainer container, IControllerFactory defaultControllerFactory)
    {
        _container = container;
        _defaultControllerFactory = defaultControllerFactory;
    }

    public IController CreateController(System.Web.Routing.RequestContext requestContext, string controllerName)
    {
        if (_container.CanResolve<IController>(controllerName))
            return _container.Resolve<IController>(controllerName);
        return _defaultControllerFactory.CreateController(requestContext, controllerName);
    }

    public System.Web.SessionState.SessionStateBehavior GetControllerSessionBehavior(System.Web.Routing.RequestContext requestContext, string controllerName)
    {
        return _defaultControllerFactory.GetControllerSessionBehavior(requestContext, controllerName);
    }

    public void ReleaseController(IController controller)
    {
        _container.Release(controller);
    }
}

Last of all, we set everything up in the Global.asax application start method, like so.

public class MvcApplication : System.Web.HttpApplication
{
    private IContainer _container;

    public static void RegisterGlobalFilters(GlobalFilterCollection filters)
    {
        filters.Add(new HandleErrorAttribute());
    }

    public static void RegisterRoutes(RouteCollection routes)
    {
         routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
         routes.IgnoreRoute("{*favicon}", new { favicon = @"(.*/)?favicon.ico(/.*)?" });

         routes.MapRoute(
            "Default", // Route name
            "{controller}/{action}/{id}", // URL with parameters
            new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
        );

    }

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

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

        _container = IoC.Ioc.Initialize(new Installer());
        var controllerFactory = new ControllerFactory(_container);
        ControllerBuilder.Current.SetControllerFactory(controllerFactory);

    }

    protected void Application_End()
    {
         _container.Dispose();
    }
}

So here we have an agnostic IoC container. In theory you can create pluggable libraries for any IoC framework and bootstrap that into your MVC application. The beauty of this is that the IoC framework becomes transparent to the MVC application, and it will always be dealing with it’s IContainer interface and not an external dependency.

If you are interested in how to implement Castle with ASP.NET MVC 3, see this link.

If you are interested in how to implement Unity with ASP.NET MVC 3, see this link.

Download code sample here.