Castle: Pick Your Lifestyle

Post 2 in a 101 series on the Castle IOC project called Windsor. See part one for background

Lifestyle Management

Often you will want to control the lifestyle of the object you create, eg a common but over used lifestyle is the singleton. Using an IoC container means you do not have to manage this in your code, which means other dependencies don't have to implicitly know they are dealing with a singleton (or whatever lifestyle is being implemented). This is good and drastically cleans up production code and makes it a lot easier to test.

So lets have a look at a new implementation we have here the MultiGreeter; a concrete implementation (or component) that tells you how often this instance has greeted you.

class MultiWriter : IWriter
{
    private int timesGreeted = 0;
    public void Write()
    {
        Console.WriteLine("I have greeted you " + timesGreeted + " time(s) before");
        timesGreeted++;
    }
}

We change the program class so we register our new component and resolve the service a couple of times to see the output:

using System;
using Castle.Windsor;

namespace CastleIocConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            var container = new WindsorContainer();
            container.AddComponent<IWriter, MultiWriter>();
            var writer1 = container.Resolve<IWriter>();
            writer1.Write();
            var writer2 = container.Resolve<IWriter>();
            writer2.Write();
            var writer3 = container.Resolve<IWriter>();
            writer3.Write();            
            Console.ReadKey();
        }
    }
}

The output is somewhat unexpected for new comers:

I have greeted you 0 time(s) before
I have greeted you 1 time(s) before
I have greeted you 2 time(s) before

Even though we have resolved the service each time to a new variable the count is incrementing. This is because Castle will resolve types as singletons by default. What we can do, if this lifestyle is inappropriate, is specify that we want the type to be of a differing type,transient for example, which would give the same behaviour associated with calling the constructor of the component each time we resolve the service (ie var writer = new MultiWriter()). This requires are slightly different way of registering our components by using the AddComponentWithLifestyle method and use the Castle.Core.LifeStyleType enumeration to select our desired lifestyle.

using System;
using Castle.Windsor;
using Castle.Core;

namespace CastleIocConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            var container = new WindsorContainer();
            container.AddComponentWithLifestyle<IWriter, MultiWriter>(LifestyleType.Transient);
            var writer1 = container.Resolve<IWriter>();
            writer1.Write();
            var writer2 = container.Resolve<IWriter>();
            writer2.Write();
            var writer3 = container.Resolve<IWriter>();
            writer3.Write();            
            Console.ReadKey();
        }
    }
}

The output is now the expected:

I have greeted you 0 time(s) before
I have greeted you 0 time(s) before
I have greeted you 0 time(s) before

This is because each time we resolve a brand new instance is created. The other Lifestyle I like is PerWebRequest (for obvious reasons).

Next we control our dependencies

Back to Post 1