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

}

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

Register，创建容器，注册服务和组件；

Resolve，获取相应组件；

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赋值为具体实现接口的类。

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