Let’s say the application structure looks like this (to keep things simple):
- MyApplication.UI (MVC)
- MyApplication.BLL (Class Library)
- MyApplication.DLL (Class Library)
Ideally, we want to have our IoC (we are using Ninject in this example) container at the composition root of our application (entry point), this is the UI project.
Time to install Ninject into our MVC project:
Now we should have a new file under
If you take a look at this file it gives us the basic setup to start binding our Interfaces to concrete implementations, but since we are going to want to Inject Interfaces and Implementations that the UI layer cannot see (Separation of concerns) then we should really encapsulate this functionality away.
Let’s create a new project (Class Library) called
MyApplication.DependencyResolver and also a project called
MyApplication.DependencyResolver.Modules. Once we have both projects add a new reference from the
UI project to the
DependencyResolver project should only reference the
Note: the two new projects will need to add the regular Ninject references
Now we have a nice structure in place I have added the following
public class CustomDependencyResolver : IDependencyResolver
public INinjectModule GetModules()
var modules = new INinjectModule
IDependencyResolver.cs (Allows us to be able to provide a different implementation or mock it out for unit testing).
public interface IDependencyResolver
public class ServiceModule : NinjectModule
public override void Load()
That’s basically all the code we require, I personally prefer to split out all my dependencies into different modules, so I would also have a
LoggingModule for my logging framework, maybe a
RepositoryModule for any repository’s I have etc.
Now going back to the
NinjectWebCommon file in the composition root of our application, there is a method called
CreateKernel(), inside this method is where we are going to want to get all of our Modules.
So I have modified the code to be like this:
private static IKernel CreateKernel()
var dependencyResolver = new CustomDependencyResolver();
var modules = dependencyResolver.GetModules();
var kernel = new StandardKernel(modules);
...Rest of the method that we are not interested about.
That is basically it, we now have passed all of our modules into the Kernel.
This also means that all the references that you do not want in the UI project are over in the
MyApplication.DependencyResolver.Modules project and the only reference you have to add to the UI is the