IoC Castle Windsor 2.1

找过一些Windsor教程的文章，博客园上TerryLee有写了不少，以及codeproject等也有一些例子，但都讲的不太明了。今天看到Alex Henderson写的一个系列，非常简单明了。下面是主要的内容

http://www.cnblogs.com/RicCC/archive/2010/03/30/castle-windsor-ioc-di.html
Part 1 - Simple configuration
Part 2 - Array Configuration
Part 3 - Dictionary configuration
Part 4 - Switching configurations
Part 5 - Configuration parameters
Part 6 - Switching between lifestyles
Part 7 - Switching implementations
Part 8 - Referencing implementations by key
Part 9 - Constructor Injection
Part 10 - Setter Injection
Part 11 - Factories
Part 12 - Decorators
Part 13 - Injecting Service Arrays
Part 14 - Startable Facility

基本示例
项目要引用Castle.Core.dll、Castle.MicroKernel.dll、Castle.Windsor.dll，引用namespace:
using Castle.Windsor;
using Castle.Windsor.Configuration.Interpreters;
假设有一个服务类TaxCalculator，用来计算税额:

01
public class TaxCalculator 

02
{ 

03
    private decimal _rate = 0.125M; 

04
    public decimal Rate 

05
    { 

06
        set { _rate = value; } 

07
        get { return _rate; } 

08
    } 

09
    public decimal CalculateTax(decimal gross) 

10
    { 

11
        return Math.Round(_rate * gross, 2); 

12
    } 

13
}

计算税额时的代码如下:

1
WindsorContainer container = new WindsorContainer(new XmlInterpreter()); 

2
TaxCalculator calculator = container.Resolve<TaxCalculator>(); 

3
decimal gross = 100; 

4
decimal tax = calculator.CalculateTax(gross); 

5
Console.WriteLine("Gross: {0}, Tax: {1}", gross, tax); 

6
Console.ReadKey();

app.config中的配置如下:

01
<configuration> 

02
    <configSections> 

03
        <section name="castle"

04
            type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" /> 

05
    </configSections> 

06
<BR> 

07
    <castle> 

08
        <components> 

09
            <component id="taxcalc.service" type="Windsor.Test.TaxCalculator, Windsor.Test"> 

10
            </component> 

11
        </components> 

12
    </castle> 

13
</configuration>

运行程序，计算结果为12.5。可以在配置文件中为Rate属性指定其他值，例如:

1
<component id="taxcalc.service" type="Windsor.Test.TaxCalculator, Windsor.Test"> 

2
    <parameters> 

3
        <Rate>0.25</Rate> 

4
    </parameters> 

5
</component>

上面的配置指定税率为0.25，因此计算结果为25

配置
如果在Windsor容器创建对象实例时，需要注入的属性为数组，而不是上面Rate这样的单个值，怎么配置？
假如要注入的属性为:

1
public DateTime[] Holidays 

2
{ 

3
    get { return _holidays; } 

4
    set { _holidays = value; } 

5
}

则可以如下配置:

01
<component id="holidays.service" type="Windsor.Test.HolidayService, Windsor.Test" > 

02
    <parameters> 

03
        <Holidays> 

04
            <array> 

05
                <item>2007-12-24</item> 

06
                <item>2007-12-25</item> 

07
                <item>2008-1-1</item> 

08
            </array> 

09
        </Holidays> 

10
    </parameters> 

11
</component>

如果要注入的属性为Dictionary类型，例如:

1
public Dictionary<string, string> Aliases 

2
{ 

3
    get { return _aliases; } 

4
    set { _aliases = value; } 

5
}

配置如下:

01
<component id="aliases.service" type="Windsor.Test.HolidayService, Windsor.Test"> 

02
    <parameters> 

03
        <Aliases> 

04
            <dictionary> 

05
                <entry key="dog">duck</entry> 

06
                <entry key="ate">broke</entry> 

07
                <entry key="homework">code</entry> 

08
            </dictionary> 

09
        </Aliases> 

10
    </parameters> 

11
</component>

注入的数组、Dictionary属性，我们都不需要初始化创建这个对象，Windsor在注入的时候会新建数组或者Dictionary对象设置给相应属性
假如，现在通过Windsor配置的服务类比较多，我建立了2份配置，一份用于测试，一份用于生产环境，如何方便的在这2份配置之间切换呢？可以在配置文件中使用include实现，示例如下:

1
<castle> 

2
    <!--<include uri="file://container-debug.config" />-->

3
    <include uri="file://container-live.config" /> 

4
</castle>

include甚至可以包含assembly中的resource（嵌入assembly中的文件）
另外可以在配置文件中定义属性，然后在其他地方引用这些属性，例如定义属性:

1
<configuration> 

2
  <properties> 

3
    <myProperty>Live</myProperty> 

4
  </properties> 

5
</configuration>

使用属性:

1
<component id="whatConfig.service" type="Windsor.Test.HolidayService, Windsor.Test"> 

2
    <parameters> 

3
        <Configuration>#{myProperty}</Configuration> 

4
    </parameters> 

5
</component>

我们可以针对同一个服务配置多个实现方式，使用id获取各个实现方式的对象实例:

01
<component id="reader.file1" type="IoC.Tutorials.Part8.FileReader, IoC.Tutorials.Part8"> 

02
    <parameters> 

03
        <FileName>file1.txt</FileName> 

04
    </parameters> 

05
</component> 

06
<component id="reader.file2" type="IoC.Tutorials.Part8.FileReader, IoC.Tutorials.Part8"> 

07
    <parameters> 

08
        <FileName>file2.txt</FileName> 

09
    </parameters> 

10
</component>

然后使用配置中的id来获取实例对象:

1
WindsorContainer container = new WindsorContainer(new XmlInterpreter()); 

2
FileReader defaultReader = container.Resolve<FileReader>(); 

3
FileReader file1Reader = container.Resolve<FileReader>("reader.file1"); 

4
FileReader file2Reader = container.Resolve<FileReader>("reader.file2");

我们可以使用container.Kernel.HasComponent(string key)方法在代码中判断特定的key是否有注册了服务

生命周期 Lifestyle, Lifecycle
Windsor容器中的对象其生命周期有以下几种方式：
Singleton: 单例模式
Transient: 临时对象模式，每次都创建一个新对象返回给请求者
PerThread: 在当前执行线程上为单例模式
Pooled: 用一个对象池管理请求对象，从对象池中返回对象实例
Custom: 实现Castle.MicroKernel.Lifestyle.ILifestyleManager或从Castle.MicroKernel.Lifestyle.AbstractLifestyleManager继承，实现自定义的对象生命周期管理
默认情况下，组件的生命周期为单例模式，可以通过配置文件进行设置:

`1`	`<component id="taxcalc.service"` `type="Windsor.Test.TaxCalculator, Windsor.Test"` `lifestyle="transient"` `/>`

也可以给class添加上[Castle.Core.Transient]、[Castle.Core.PerThread]等属性来设置组件的生命周期，从而忽略配置文件中的设置
Windsor支持Castle.Core.IInitializable和System.IDisposable接口，如果类实现了IInitializable接口，容器在创建对象实例之后会执行接口的Initialize方法；如果类实现了IDisposable接口，则在销毁对象的时候会执行Dispose方法

构造器注入
前面示例我们用的都是setter注入，下面示例使用构造器注入
有一个用于字符串编码的接口，该接口有2个实现:

01
public interface IEncoder 

02
{ 

03
string Encode(string source); 

04
} 

05
public class NullEncoder : IEncoder 

06
{ 

07
public string Encode(string source) 

08
{ 

09
return source; 

10
} 

11
} 

12
public class SillyEncoder : IEncoder 

13
{ 

14
    private char[] _mixedUp = "YACBDFEGIHJLKMONPRSQTUWVXZ".ToCharArray(); 

15
<BR> 

16
    public string Encode(string source) 

17
    { 

18
        string upperSource = source.ToUpper(); 

19
        char[] encoded = new char[source.Length]; 

20
        for (int i = 0; i < encoded.Length; i++) 

21
        { 

22
            encoded[i] = MapCharacter(upperSource[i]); 

23
        } 

24
        return new string(encoded); 

25
    } 

26
<BR> 

27
    private char MapCharacter(char ch) 

28
    { 

29
        if ((ch >= 'A') && (ch <= 'Z')) 

30
        { 

31
            return _mixedUp[ch - 'A']; 

32
        } 

33
        return ch; 

34
    } 

35
}

然后有一个发送消息的类，其构造函数要求一个IEncode对象:

01
public class MessageSender 

02
{ 

03
    private readonly IEncoder _encoder; 

04
    private readonly string _from; 

05
    public MessageSender(string from, IEncoder encoder) 

06
    { 

07
        _from = from; 

08
        _encoder = encoder; 

09
    } 

10
    public void SendMessage(string to, string body) 

11
    { 

12
        Console.WriteLine("to: {0}\r\nfrom: {1}\r\n\r\n{2}", to, _from, _encoder.Encode(body)); 

13
    } 

14
}

使用Windsor可以实现：Windsor自动创建一个IEncoder对象提供给MessageSender的构造函数；在配置文件中需要指定from参数的值，否则Windsor将抛出异常无法创建MessageSender对象
使用的代码如下:

1
WindsorContainer container = new WindsorContainer(new XmlInterpreter()); 

2
MessageSender sender = container.Resolve<MessageSender>(); 

3
sender.SendMessage("hammet", "castle is great!"); 

4
Console.ReadKey();

配置如下:

01
<component id="encoder.silly"

02
    service="Windsor.Test.IEncoder, Windsor.Test"

03
    type="Windsor.Test.SillyEncoder, Windsor.Test" /> 

04
<component id="encoder.null"

05
    service="Windsor.Test.IEncoder, Windsor.Test"

06
    type="Windsor.Test.NullEncoder, Windsor.Test" /> 

07
<component id="messageSender"

08
    type="Windsor.Test.MessageSender, Windsor.Test"> 

09
    <parameters>MessageSender 

10
        <from>alex@bittercoder.com</from> 

11
    </parameters> 

12
</component>

上面我们有2个IEncoder的实现，我们可以在配置文件中为MessageSender的构造函数指定使用哪一个实现类:

1
<component id="messageSender"

2
    type="Windsor.Test.MessageSender, Windsor.Test"> 

3
    <parameters>MessageSender 

4
        <from>alex@bittercoder.com</from> 

5
        <encoder>${encoder.null}</encoder> 

6
    </parameters> 

7
</component>

Factory Facilities
我们自己写的类完全由我们自己控制，因此我们可以让他们能够通过Windsor容器管理，但对于某些第三方提供的服务程序，可能构造函数存在额外的依赖性，使得我们无法通过配置直接使用Windsor容器来管理，这种情况下可以使用Windsor的Factory Facilities实现一个工厂，告诉Windsor使用我们的工厂来创建特定的服务对象实例
比如我们实现了下面这样一个工厂类，用来创建一个ISmsService服务对象:

01
public class SmsServiceFactory 

02
{ 

03
    private string _userName; 

04
    private string _password; 

05
    private int _retryAttempts = 3; 

06
<BR> 

07
    public SmsServiceFactory(string userName, string password) 

08
    { 

09
        _userName = userName; 

10
        _password = password; 

11
    } 

12
    public int RetryAttempts 

13
    { 

14
        get { return _retryAttempts; } 

15
        set { _retryAttempts = value; } 

16
    } 

17
<BR> 

18
    public ISmsService CreateService() 

19
    { 

20
        SmsService service = new SmsService(); 

21
        SmsService.SmsConfig config = new SmsService.SmsConfig(); 

22
        config.SetCredentials(_userName, _password); 

23
        config.RetryAttempts = _retryAttempts; 

24
        service.SetConfig(config); 

25
        return service; 

26
    } 

27
}

然后我们使用下面的配置，通过Windsor Factory Facilities指定我们所使用的工厂类:

01
<castle> 

02
    <facilities> 

03
        <facility

04
            id="factorysupport"

05
            type="Castle.Facilities.FactorySupport.FactorySupportFacility, Castle.MicroKernel" /> 

06
    </facilities> 

07
    <components> 

08
        <component id="smsService.Factory"

09
            type="Windsor.Test.SmsServiceFactory, Windsor.Test"> 

10
            <parameters> 

11
                <userName>joe</userName> 

12
                <password>secret</password> 

13
            </parameters> 

14
        </component> 

15
        <component id="smsService.default"

16
            type="Windsor.Test.ISmsService, Windsor.Test"

17
            factoryId="smsService.Factory"

18
            factoryCreate="CreateService" /> 

19
    </components> 

20
</castle>

使用的代码跟其他示例一样:

1
WindsorContainer container = new WindsorContainer(new XmlInterpreter()); 

2
ISmsService smsService = container.Resolve<ISmsService>(); 

3
smsService.SendMessage("+465556555", "testing testing...1.2.3");

Tag标签: Castle,IoC

riccc
关注 - 4
粉丝 - 34

关注博主