Question

I’m just getting started with IoC containers and have picked up Ninject to start with. I understand the principle of the separate modules you can incorporate into a Kernel. But I’m curious if I should have the first line below everywhere in my code where I’m about to ask for the concrete implementation of something from my service layer.

IKernel kernel = new StandardKernel(new SimpleModule());
// example: getting my ContentService
IContentService contentService = kernel.Get<IContentService>();

If I have a class with 10 methods that use the ContentService should I really new up a Module and a Kernel in every method? Seems like a code smell. How do most developers handle this with Ninject? Are there any articles online that show the proper way to do this with the consumer class?

Answer 1

There are, basically two ways of working with IoC: Dependency Injection (DI) and Service Location (SL).
When dealing with dependecy injection, you provide you dependencies from outside your classes. Generally, you do this by injecting (passing) your dependencies into the class constructor or by using setters. For example:

public class SomeClass {
        public ISomeDependency SomeDependency {get;set;} 

        public SomeClass(ISomeOtherDependecy someOtherDependency) {
           //...
        }
}

In this case, you COULD provide a ISomeDependency implementation through the property and you SHOULD provide ISomeOtherDependecy implementation through the constructor. Ninject support both ways.

The other way of doing (SL) allows you to request for your dependencies in the moment you need, for example:

public void DoSomeAction() {
   ISomeDependency someDependency = MyServiceLocatorImpl.GetInstance<ISomeDependence>()
}

If you plan to use the SL approach (or an hybrid one), you could use the Common Service Locator (Ninject has support for it) . It makes easy to switch our IoC engine later.