[Castle Windsor]学习依赖注入

初次尝试使用Castle Windsor实现依赖注入DI，或者叫做控制反转IOC。

参考：

https://github.com/castleproject/Windsor/blob/master/docs/README.md

http://terrylee.cnblogs.com/archive/2006/04/17/377018.html

依赖注入就是基于接口interface编程，而不是具体的类，实现松耦合，易于单元测试，将接口定义为服务，具体实现某一服务的类为组件。

Windsor有一个基础的用例。

一个类库工程中有两个接口IDependency1、IDependency2：

namespace ClassLibrary1
{
    public interface IDependency1
    {
        object SomeObject { get; set; }
    }

    public interface IDependency2
    {
        object SomeOtherObject { get; set; }
    }
}

实现它们的类：

namespace ClassLibrary1
{
    public class Dependency1 : IDependency1
    {
        public object SomeObject { get; set; }
    }

    public class Dependency2 : IDependency2
    {
        public object SomeOtherObject { get; set; }
    }
}

创建Main类，作为这个库的入口类：

namespace ClassLibrary1
{
    public class Main
    {
        private IDependency1 object1;
        private IDependency2 object2;

        public Main(IDependency1 dependency1, IDependency2 dependency2)
        {
           object1 = dependency1;
           object2 = dependency2;
        }

        public void DoSomething()
        {
           object1.SomeObject = "Hello World";
           object2.SomeOtherObject = "Hello Mars";
        }
    }
}

接下来是如何使用上面创建的类库，以一个winform项目为例，通过NuGet安装Castle.Core、Castle.Windsor，在winform中通过一个按钮事件注册接口：

using Castle.MicroKernel.Registration;
using Castle.Windsor;

private void button1_Click(object sender, EventArgs e)
{
    // CREATE A WINDSOR CONTAINER OBJECT AND REGISTER THE INTERFACES, AND THEIR CONCRETE IMPLEMENTATIONS.
    var container = new WindsorContainer();
    container.Register(Component.For<Main>());
    container.Register(Component.For<IDependency1>().ImplementedBy<Dependency1>());
    container.Register(Component.For<IDependency2>().ImplementedBy<Dependency2>());

    // CREATE THE MAIN OBJECT AND INVOKE ITS METHOD(S) AS DESIRED.
    var mainThing = container.Resolve<Main>();
    mainThing.DoSomething();

　　container.Dispose();

}

以上是全部用例。简单说一共三步:

1. Register，创建容器，注册服务和组件；
2. Resolve，获取相应组件；
3. Release，在程序结束时释放资源。

三种依赖注入方式，构造器注入，通过构造函数来提供：

    public class Main
    {
        private IDependency1 object1;
        private IDependency2 object2;

        public Main(IDependency1 dependency1, IDependency2 dependency2)
        {
           object1 = dependency1;
           object2 = dependency2;
        }
　　}

属性注入，依赖可有可无的时候很有用，暴露一个可写的属性，允许客户提供不同的依赖实现：

    public class Main
    {
        public IDependency1 object1{ get; set; }
        public IDependency2 object2{ get; set; }
　　}

在使用这个类时，为object1、object2赋值为具体实现接口的类。

方法注入，当依赖对于每个方法调用都不同的时候，可以通过一个方法参数来实现，提供不同的类对象作为参数，就可以有不同的调用效果。

关键字：.NET,DI,Castle Windsor