使用Autofac实现依赖注射及Ioc

Ioc（Inverse of control）已经是叫嚷了很久的技术了，一直没有机会细看，最近因为看源代码的关系，研究了一点，拿出来分享一下。

当前网络上有很多Ioc的框架，比如说微软的企业库就使用Ioc技术重写了，还有Prism模式也用到了Ioc。我看的函数库是Autofac，但是理念跟其他的函数库大同小异，实际上，为了方便程序员在不同的Ioc框架上移植程序，各个框架的编写者开会定义了一个大家都支持的接口集：Common Service Locator。

什么是Ioc

Ioc简言之，就是将类似下面创建对象的代码—我们称之为情况1：

var checker  =   new  MemoChecker(memos,  new  PrintingNotifier(Console.Out));

转换成下面这样—称之为情况2：

var checker  =  container.Resolve < MemoCheck > ();

而container.Resolve<MemoCheck>这一行代码在创建MemoCheck这个类型的实例时，又可以通过下面的代码创建MemoCheck构造函数所需要的两个参数：

new  MemoChecker(container.Resolve < IQueryable < Memo >> (),
                container.Resolve < IMemoDueNotifier > ())

情况2相对情况1的好处在于，在情况1 的代码里，程序员需要显式指定构建MemoChecker实例所要求的参数类型的实例。也就是说，MemoChecker在构造一个实例时，你需要显式传入第二个参数的具体实例（PrintingNotifier）。这样就导致一个问题，如果在后期程序发布以后，需要更换MemoCheck的第二个参数，那就只有修改程序代码一条路可走了。

针对于情况1的这个问题，那肯定有人会说，那就把MemoChecker构造函数的第二个参数定义成一个接口，然后在创建MemoChecker实例的时候，读一个配置文件，找到实现这个接口的具体类型，通过反射等机制创建对象传给MemoChecker的构造函数。这样就可以通过修改配置文件的方式，通过添加实现接口的插件，动态地修改程序的行为—这正是情况2所要做的，也就是Ioc和依赖注入（Dependence Injection）要解决的一个通用问题。

关于Ioc和依赖注入，网上已经有很多文章讲解这个概念了，有兴趣的朋友可以看看这篇文章，里面介绍的很详细：

http://martinfowler.com/articles/injection.html

使用Autofac实现依赖注入

我先以CodeProject的一个示例代码为例，讲解一下用Autofac实现依赖注入的基本步骤，下面是代码：

 1  using  System;
 2  using  System.Collections.Generic;
 3  using  System.Linq;
 4  using  System.IO; 
 5  using  Autofac;
 6 
 7  namespace  Remember
 8  {
 9       interface  IMemoDueNotifier
10      {
11           void  MemoIsDue(Memo memo);
12  }
13 
14       class  Memo
15      {
16           public   string  Title {  get ;  set ; }
17           public  DateTime DueAt {  get ;  set ; }
18  } 
19 
20       class  MemoChecker
21      {
22           readonly  IList < Memo >  _memos;
23           readonly  IMemoDueNotifier _notifier;
24 
25           public  MemoChecker(IList < Memo >  memos, IMemoDueNotifier notifier)
26          {
27              _memos  =  memos;
28              _notifier  =  notifier;
29          }
30 
31           public   void  CheckNow()
32          {
33              var overdueMemos  =  _memos.Where(memo  =>  memo.DueAt  <  DateTime.Now);
34 
35               foreach  (var memo  in  overdueMemos)
36                  _notifier.MemoIsDue(memo);
37          }
38      }
39 
40       class  PrintingNotifier : IMemoDueNotifier
41      {
42           readonly  TextWriter _writer;
43 
44           public  PrintingNotifier(TextWriter writer)
45          {
46              _writer  =  writer;
47          }
48 
49           public   void  MemoIsDue(Memo memo)
50          {
51              _writer.WriteLine( " Memo '{0}' is due! " , memo.Title);
52          }
53  }
54 
55       class  Program
56      {
57           static   void  Main()
58          {
59              var memos  =   new  List < Memo >  {
60                   new  Memo { Title  =   " Release Autofac 1.1 " , 
61                             DueAt  =   new  DateTime( 2007 ,  03 ,  12 ) },
62                   new  Memo { Title  =   " Update CodeProject Article " , 
63                             DueAt  =  DateTime.Now },
64                   new  Memo { Title  =   " Release Autofac 3 " , 
65                             DueAt  =   new  DateTime( 2011 ,  07 ,  01 ) }
66              };
67 
68              var builder  =   new  ContainerBuilder();
69              builder.Register(c  =>   new  MemoChecker(
70                  c.Resolve < IList < Memo >> (), c.Resolve < IMemoDueNotifier > ()));
71              builder.RegisterType < PrintingNotifier > ().As < IMemoDueNotifier > ();
72              builder.RegisterInstance(memos).As < IList < Memo >> ();
73                 
74              builder.RegisterInstance(Console.Out)
75                     .As < TextWriter > ()
76                     .ExternallyOwned();
77 
78               using  (var container  =  builder.Build())
79              {
80                  container.Resolve < MemoChecker > ().CheckNow();
81              }
82 
83              Console.WriteLine( " Done! Press any key. " );
84              Console.ReadKey();
85          }
86      }
87  }
88 

这个程序的作用是检查所有的记事项，提醒用户这些过期的记事项。这个程序里最主要的类是MemoChecker，MemoChecker需要两个对象才能构建一个实例—Memo和IMemoDueNotifier。而这两个类型的对象，是由autofac自行解析的，autofac知道如何找到一个接口是由哪个对象实现的—这个过程叫做Resolve。而接口和实现接口对象的对映关系是由程序员在配置文件app.config，或者自己在程序的入口处（例如Main函数）注册好的—这个过程叫Register。因为实现接口的某些对象，有可能它的构造函数也会接受其他接口，而实现这些接口的对象也需要解析。因此，Autofac将所有的接口，和实现接口的对象都放到一个容器里，这个容器自己解析实现接口的对象之间的依赖关系—也就是ContainerBuilder。ContainerBuilder在Build的过程中，通过多次调用Resolve解决容器内部的对象依赖关系。当依赖关系都解析完毕以后，以后要创建对象，不需要再用类似下面的代码显式创建了：

var builder  =   new  MemoChecker();

创建对象的工作，全部都交给Container解决，Container自己在内部找到构造对象时，Container创建调用构造函数要用到的参数的对象，解决对象之间的依赖关系，然后你只要用类似下面的代码就可以获取到你要的对象：

var builder  =  container.Resolve < MemoChecker > ();

使用Autofac基于配置文件实现依赖注入

前面讲到的依赖注入，还是基于代码的，很多时候，使用Ioc和依赖注入技术，主要是为了支持插件技术。比如说，其他插件只要实现了定义的接口，那么，终端用户理论上可以只通过将实现插件的assembly拷贝到程序文件夹，并修改配置文件的形式来无缝集成新的插件。

那我们来看Autofac自带的例子—Calculator。这个程序有三个Assembly组成，Calculator是那个支持插件的程序；Calculator.Api包括了接口的定义，这样，Calculator和它的插件通过引用这个Assembly，就可以实现相互交互了；而Calculator.Operations就是最后实现接口的一些插件。

我们来看一看代码：

Calculator.Api定义了一个接口—这个接口将会被Calculator（支持插件的程序）和Calculator.Operations（插件）所使用：

 1  using  System;
 2 
 3  namespace  Calculator.Api
 4  {
 5       public   interface  IOperation
 6      {
 7           string  Operator
 8          {
 9               get ;
10          }
11 
12           double  Apply( double  lhs,  double  rhs);
13      }
14  }
15 

而在Calculator这个Assembly里，定义了一个Calculator这个类，枚举所有实现了IOperation的插件—这个枚举过程由Autofac自动完成：

 1  using  System;
 2  using  System.Collections.Generic;
 3  using  System.Linq;
 4  using  System.Text;
 5  using  Calculator.Api;
 6 
 7  namespace  Calculator
 8  {
 9       class  Calculator
10      {
11          IDictionary < string , IOperation >  _operations  =   new  Dictionary < string , IOperation > ();
12 
13           public  Calculator(IEnumerable < IOperation >  operations)
14          {
15               if  (operations  ==   null )
16                   throw   new  ArgumentNullException( " operations " );
17 
18               foreach  (IOperation op  in  operations)
19                  _operations.Add(op.Operator, op);
20          }
21 
22           public  IEnumerable < string >  AvailableOperators
23          {
24               get
25              {
26                   return  _operations.Keys;
27              }
28          }
29 
30           public   double  ApplyOperator( string  op,  double  lhs,  double  rhs)
31          {
32               if  (op  ==   null )
33                   throw   new  ArgumentNullException( " op " );
34 
35              IOperation operation;
36               if  ( ! _operations.TryGetValue(op,  out  operation))
37                   throw   new  ArgumentException( " Unsupported operation. " );
38 
39               return  operation.Apply(lhs, rhs);
40          }
41      }
42  }
43 

请注意Calculator的构造函数，这个构造函数接受一个IEnumerable<IOperation>类型的参数，这个参数是autofac通过读取配置文件自动构建好一个实例，下面就是app.config文件里的具体设置：

 1  <? xml version="1.0" ?>
 2  < configuration >
 3     < configSections >
 4       < section  name ="calculator"  type ="Autofac.Configuration.SectionHandler, Autofac.Configuration" />
 5     </ configSections >
 6 
 7     < calculator  defaultAssembly ="Calculator.Api" >
 8       < components >
 9         < component  type ="Calculator.Operations.Add, Calculator.Operations"  member-of ="operations" />
10         < component  type ="Calculator.Operations.Multiply, Calculator.Operations"  member-of ="operations" />
11 
12         < component  type ="Calculator.Operations.Divide, Calculator.Operations"  member-of ="operations" >
13           < parameters >
14             < parameter  name ="places"  value ="4" />
15           </ parameters >
16         </ component >
17 
18       </ components >
19     </ calculator >
20 
21  </ configuration >
22 

 

在程序（Calculator）启动的时候，调用Autofac API里面的ContainerBuilder.RegisterModule来告诉Autofac读取配置文件里的接口与实现接口对象的映射关系。

 1  namespace  Calculator
 2  {
 3 
 4       static   class  Program
 5      {
 6          [STAThread]
 7           static   void  Main()
 8          {
 9               try
10              {
11                  var builder  =   new  ContainerBuilder();
12 
13                  ...
14 
15                  builder.RegisterModule( new  ConfigurationSettingsReader( " calculator " ));
16 
17                  ...
18              }
19               catch  (Exception ex)
20              {
21                  DisplayException(ex);
22              }
23          }
24      }
25  }
26