Project DescriptionSimpleContainer is very simple
IoC container that consists of one class that implements two remarkable methods: one for registration and one for resolving.
The container class is implemented as
CommonServiceLocator adapter and so it can be easily used in existing applications.
You can read about SimpleContainer development
on my blog.
Quick start
// create container
var container = new SimpleContainer();
// register MyClass class for IMyInterface
container.Register<IMyInterface, MyClass>(); // if MyClass constructor has some parameter then these are resolved (dependency injection!)
// resolve instance
var instance = container.GetInstance<IMyInterface>();
Core usage
var container = new SimpleContainer();
// register new delegate (lambda function) for IMyInterface type resolving
container.Register(typeof (IMyInterface), null/* no key */, (cont, type, key) => new MyClass());
// resolve the instance
IMyInterface iface = container.GetInstance<IMyInterface>();
The
Register method is the only one registration method that is available in
SimpleContainer. More powerfull registration methods are available as extension methods (see bellow).
Resolving: The
SimpleContainer class implements
ServiceLocatorImplBase abstract class from
CommonServiceLocator project and this determines the way how instances are resolved - just use
GetInstance method (there is generic and non-generic overload).
When you are using some other IoC container via
CommonServiceLocator then you can easily migrate to
SimpleContainer. Or if you are using
SimpleContainer and you want to use some more powerfull IoC container then you can easily migrate too. You don't have to rewrite whole application, you have to change just the registrations (which are
always container specific).
So when you decide to use
SimpleContainer then you can easily migrate to some other IoC container that has
CommonServiceLocator adapter too and vice versa.
Standard usage
I'm sure that you don't want to specify delegate for each resolved type. So the project contains the second class with extension methods that make our life easier:
// registration using generic
container.Register<IMyInterface>((cont, type, key) => new MyClass());
// call to MyClass constructor is made automatically
// if MyClass constructor has some parameter then these are resolved (dependency injection!)
container.Register<IMyInterface, MyClass>();
// one instance registration (the resolving just returns this instance)
container.RegisterInstance<IMyInterface>(new MyClass());
// the same as above but the instance is automatically disposed when container is disposed
container.RegisterSingleton<IMyInterface>(new MyClass());
// there is more registration methods, i.e. for resolve overloading (via container hierarchy)
Extended usage
You can of course write your own extensions methods that handle your specific scenario. As example, I added classes for type registration that ensures that the same instance will be returned during one web-request.
container.RegisterForOneRequest<IMyInterface, MyClass>();
The implementation uses
HttpContext.Current.Items class which is accessed via custom
HttpModule -
SimpleContainerWebRequestLifetimeModule. So when you want to use this feature in your web application then you have to register this module in your
web.config file.
<configuration>
<system.web>
<httpModules>
<add name="SimpleContainerWebRequestLifetime" type="SimpleContainerWebRequestLifetimeModule"/>
</httpModules>
</system.web>
<system.webServer>
<modules>
<remove name="SimpleContainerWebRequestLifetime" />
<add name="SimpleContainerWebRequestLifetime" type="SimpleContainerWebRequestLifetimeModule"/>
</modules>
</system.webServer>
</configuration>