Project-Embedded IoC Container

Question

I am looking for a really simple and lightweight IoC Container whose C# source can be included in my own project (thus not making an external reference).

The reason for this is that I am writing an infrastructure and would like to provide a single .dll file, without any additional dependencies.

I also do not want to ILMerge my assembly with the IoC assembly..

I thought about MEF, some other suggestions?

Answer 1

If you're using .NET 4.0 you have MEF included.

For .NET 2 I once wrote something similar using interfaces and Reflection. There are a lot of tutorials out there describing that process. Even if you can use MEF, its still worth attempting some reflection tutorials as this is how MEF works underneath.

Also check out this question which has some good answers. TinyIoC looks like its just a single source file.

Answer 2

If you don't need anything fancy, a DI container can be really short:

public class Container
{
   private readonly Dictionary<Type,Func<Container,object>> factories;
   private readonly Dictionary<Type,object> cache;

   public Container()
   {
       this.factories = new Dictionary<Type,Func<Container,object>>();
       this.cache = new Dictionary<Type,object>();
   }

   public void Register<TContract>(Func<Container,TContract> factory)
   {
       // wrap in lambda which returns object instead of TContract
       factories[typeof(TContract)] = c => factory(c);
   }

   public TContract Get<TContract>()
   {
       var contract = typeof(TContract);
       if (!cache.ContainsKey(contract))
       {
           this.cache[contract] = this.factories[contract](this);
       }
       return (TContract)this.cache[contract];
   }
}

Which you would use like this:

var container = new Container();
container.Register<ICar>(c => new Car(
    c.Get<IEngine>(), c.Get<IWheel>()));
container.Register<IWheel>(c => new Wheel());
container.Register<IEngine>(c => new Engine());

var car = container.Get<ICar>();

Even more minimalistic would be to do dependency injection without a container:

IWheel wheel = new Wheel();
IEngine engine = new Engine();
ICar car = new Car(engine, wheel);

However, for complex object graphs it can quickly get complicated to maintain the correct construction order during refactorings. The container doesn't have this problem.