话说依赖注入

过往项目中，如果要实现动态创建对象实例，往往会通过XML(接口对应实现类映射)+工厂模式进行实现，如今有一种更加简便的实现方式，那就是通过Ninject

引用网上小段DEMO： 

 首先，是一个接口。还是从 HelloWorld 开始吧。

public interface IHelloWorld
{
    /// <summary>
    /// 定义接口.
    /// </summary>
    string HelloWorld();
}
 
然后是接口的两个实现.
public class HelloWorldEnglish : IHelloWorld
{
    string IHelloWorld.HelloWorld()
    {
        return "Hello World !";
    }
}
public class HelloWorldChinese : IHelloWorld
{
    string IHelloWorld.HelloWorld()
    {
        return "您好 世界 ！";
    }
}

然后是一个使用接口的类。
using Ninject;
public class People
{
    #region  以构造函数方式. 实现依赖注入.
    private readonly IHelloWorld  peopleHelloWorld;
   [Inject]
    public People(IHelloWorld helloWorld)
    {
        if (helloWorld == null)
            throw new ArgumentNullException("helloWorld");
        this.peopleHelloWorld = helloWorld;
    }
    #endregion
    public void SayHello()
    {
        Console.WriteLine(this.peopleHelloWorld.HelloWorld());
    }
}

===== 上面是基本的 接口、实现、业务
 
===== 下面是 Ninject Modules 的配置.
using Ninject.Modules;
/// <summary>
/// 注册的接口和接口实现类.
///
///
/// NinjectModule
/// 是通过在 Load() 方法中。
///
/// 指定 接口的具体实现.
///
/// </summary>
public class MyModules1 : NinjectModule
{
    public override void Load()
    {
        // 指定 IHelloWorld  接口的实现 为 HelloWorldChinese
        // ## To 方法：绑定到接口的具体实现。
        Bind<IHelloWorld>().To<HelloWorldChinese>();
    }
}
public class MyModules2 : NinjectModule
{
    public override void Load()
    {
        // 指定 IHelloWorld  接口的实现 为 HelloWorldEnglish
        // ## To 方法：绑定到接口的具体实现。
        Bind<IHelloWorld>().To<HelloWorldEnglish>();
    }
}

===== 最后就是用于测试的 Main 了
using Ninject;
/// <summary>
/// Ninject 最基础演示例子.
/// </summary>
class Program
{
    static void Main(string[] args)
    {
        #region 不使用 Ninject 的方式.
        Console.WriteLine("不使用 Ninject 的方式.");
        // P1.
        People p1 = new People(new HelloWorldEnglish());
        p1.SayHello();
        // P2.
        People p2 = new People(new HelloWorldChinese());
        p2.SayHello();
        #endregion

        Console.WriteLine("####################");

        #region 使用 Ninject 的方式.
        Console.WriteLine("使用 Ninject 的方式.");
        using (IKernel  kernel = new StandardKernel(new MyModules1()))
        {
            People p = kernel.Get<People>();
            p.SayHello();
        }
        using (IKernel kernel = new StandardKernel(new MyModules2()))
        {
            People p = kernel.Get<People>();
            p.SayHello();
        }
        #endregion

        Console.ReadLine();
    }
}

运行输出的结果：
不使用 Ninject 的方式.
Hello World !
您好 世界 ！
####################
使用 Ninject 的方式.
您好 世界 ！
Hello World !

小结：

Ninject 通过 [Inject]、NinjectModule 与 Kernel 实现 依赖注入的处理。

需要被注入的 地方，加上 [Inject] 标记。

继承 NinjectModule 类的实现中。
通过 Bind，对于接口，具体定义使用哪一种实现。

最后

通过 Kernel.Get 来获取 Module 中定义的实现.