Question

I’m a complete newbie to ninject

I’ve been pulling apart someone else’s code and found several instances of nInject modules – classes that derive from Ninject.Modules.Module, and have a load method that contains most of their code.

These classes are called by invoking the LoadModule method of an instance of StandardKernel and passing it an instance of the module class.

Maybe I’m missing something obvious here, but what is the benefit of this over just creating a plain old class and calling its method, or perhaps a static class with a static method?

 

Answer 1

The Ninject modules are the tools used to register the various types with the IoC container. The advantage is that these modules are then kept in their own classes. This allows you to put different tiers/services in their own modules.

// some method early in your app's life cycle
public Kernel BuildKernel()
{
    var modules = new INinjectModule[] 
    {
        new LinqToSqlDataContextModule(), // just my L2S binding
        new WebModule(),
        new EventRegistrationModule()
    };
    return new StandardKernel(modules);
}

// in LinqToSqlDataContextModule.cs
public class LinqToSqlDataContextModule : NinjectModule
{
    public override void Load()
    {
        Bind<IRepository>().To<LinqToSqlRepository>();
    }
}

Having multiple modules allows for separation of concerns, even within your IoC container.

The rest of you question sounds like it is more about IoC and DI as a whole, and not just Ninject. Yes, you could use static Configuration objects to do just about everything that an IoC container does. IoC containers become really nice when you have multiple hierarchies of dependencies.

public interface IInterfaceA {}
public interface IInterfaceB {}
public interface IInterfaceC {}

public class ClassA : IInterfaceA {}

public class ClassB : IInterfaceB
{
    public ClassB(IInterfaceA a){}
}

public class ClassC : IInterfaceC
{
    public ClassC(IInterfaceB b){}
}

Building ClassC is a pain at this point, with multiple depths of interfaces. It’s much easier to just ask the kernel for an IInterfaceC.

var newc = ApplicationScope.Kernel.Get<IInterfaceC>();