Ninject模块的意图是什么？ [英] What is the intention of Ninject modules?

问题描述

我是一个完整的新手ninject

I'm a complete newbie to ninject

我一直在剥夺别人的代码，并发现了nInject模块的几个实例 - 派生自Ninject.Modules的类.Module，并且有一个包含大部分代码的加载方法。

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.

这些类是通过调用StandardKernel实例的LoadModule方法来调用的，并传递一个模块类。

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?

 

推荐答案

Ninject模块是用于向IoC容器注册各种类型的工具。优点是这些模块然后保存在自己的类中。这允许您在自己的模块中放置不同的层/服务。

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>();
    }
}

拥有多个模块允许分离问题，即使在您的IoC容器。

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

其余的问题听起来像是更多关于IoC和DI的整体，而不仅仅是Ninject。是的，您可以使用静态配置对象来完成IoC容器所做的所有操作。当您有多个层次结构的依赖关系时，IoC容器变得非常好。

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){}
}

建立ClassC在这一点上是一个痛苦，具有多个接口深度。只需向内核询问一个IInterfaceC就可以轻松得多。

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>();

这篇关于Ninject模块的意图是什么？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！