Autofac入门示例 - 上 - 备忘录

上一篇搞清楚了Autofac是什么东东后，这篇我们就开始说一下他怎么用，Autofac最大的优点就是他太简单方便了，既可以用配置文件，也可以用代码来装配。

Autofac的装配工作主要是分三步：

1. 创建一个ContainerBuilder，容器构建器。
2. 登记服务和组件，就是程序中所用到的实现了指定接口的类。
3. 注册实例对象，就是把一些实例注册进行，Autofac在用的时候会自已过来拿
4. 最后生成容器，Autofac会自动的检测依赖关系，然后进行自动装载。
5. 最最后就是通过构造出来的IContainer取对象实例了。

弄清楚了步骤现在就看一下官方所给出的示例，范例有两个，一个是备忘录程序，一个是计算器（让我想起了曾经的一个面试题），现在先从备忘录开始吧，原文是英文的，如果英语好的同志直接看原版，英文一般的同志可以听我接下来的唠叨。

原文：http://www.codeproject.com/KB/architecture/di-with-autofac.aspx （英文）
源程序：http://www.codeproject.com/KB/architecture/di-with-autofac/autofac-example.zip

运行后的效果是：

看一下官方提供的类的关系图：

首先建一个控制台应用程序，工程名为Remember。偷个懒不截图了，大家都明白吧。现在展示一下这几个核心类是什么样以及它们的功能。

从上面的类图中我们可以粗略的看出，有一个Memo的类，当然它就是我们的主角（备忘录实体）

View Code

1  namespace  Remember
2  {
3       using  System;
4       public   class  Memo
5      {
6           public  DateTime DueAt {  get ;  set ; }
7           public   string  Title {  get ;  set ; }
8      }
9  }

MemoChecker顾名思意就是备忘录检查器，它是用来处理备忘录的工作者。

View Code

 1  namespace  Remember
 2  {
 3       using  System;
 4       using  System.Linq;
 5 
 6       class  MemoChecker
 7      {
 8          IQueryable < Memo >  _memos;
 9          IMemoDueNotifier _notifier;
10 
11           public  MemoChecker(IQueryable < Memo >  memos, IMemoDueNotifier notifier)
12          {
13               this ._memos  =  memos;
14               this ._notifier  =  notifier;
15          }
16 
17           public   void  CheckNow()
18          {
19              var overdueMemos  =  _memos.Where(
20                  memo  =>  memo.DueAt  <  DateTime.Now);
21 
22               foreach  (var memo  in  overdueMemos)
23                  _notifier.MemoIsDue(memo);
24          }
25      }
26  }

还有一个接口IMemoDueNotifier，它是提醒者，该接口被备忘录检查器调用，以便在检查到过期的备忘录实体时提示。

View Code

1  namespace  Remember
2  {
3       interface  IMemoDueNotifier
4      {
5           void  MemoIsDue(Memo memo);
6      }
7  }

具体的提示方式则是由实现了IMemoDueNotifier的具体类来完成的，它们之间的契约是必须继承了TextWriter的类对能作为输出源（比如Console.Out输出到屏幕，StringWriter输出到字符串中，HttpWriter输出到Response.Write流等等），在该示例中实现了PrintingNotifier类来向屏幕中输出过期的备忘录实体。

View Code

 1  namespace  Remember
 2  {
 3       using  System.IO;
 4       public   class  PrintingNotifier : IMemoDueNotifier
 5      {
 6          TextWriter _writer;
 7           public  PrintingNotifier(TextWriter writer)
 8          {
 9              _writer  =  writer;
10          }
11 
12           public   void  MemoIsDue(Memo memo)
13          {
14              _writer.WriteLine( " Memo '{0}' is due! " , memo.Title);
15          }
16      }
17  }

这些类都很简单，建议同志们打开VS，引入Autofac然后自己亲自在电脑上敲一遍可以加深印象。而不仅仅时看一遍就过去了，很容易忘记的。

好了现在我们把刚刚那几个类已经将这些东东都完成了，但是它们还不能一起配合着干起活来。

最后看一下主程序的代码吧，在这里我们将把这些类都组织起来让他们一起工作。在这里我写了一种传统的直接new的方式，也写了使用Autofac的方式，两个方式运行出来的结果是一样的。但是我们通过Autofac注册的方式来处理系统中的所有类和接口（也称组件和服务）时，它们变得很离散，之间都没有耦合，我们需要什么对象时只需要象本示例中一样调用container.Resolve<MemoChecker>() 这个Resolve方法既可。这样我们就可以灵活的替换多个类。

View Code

 1  namespace  Remember
 2  {
 3       using  System;
 4       using  System.IO;
 5       using  System.Linq;
 6       using  Autofac;
 7 
 8       class  Program
 9      {
10           static  IQueryable < Memo >  memos  =   new []{
11                   new  Memo{ Title = " Release Autofac 1.0 " , DueAt  =   new  DateTime( 2007 , 12 , 14 )},
12                   new  Memo{ Title = " Write CodeProject Article " , DueAt  =  DateTime.Now},
13                   new  Memo{ Title = " Release Autofac 2.3 " , DueAt  =   new  DateTime( 2010 , 07 , 01 )}
14              }.AsQueryable();
15 
16           static   void  Main( string [] args)
17          {
18               /*
19               * 以传统的依赖高度耦合的方式创建对象，
20              IMemoDueNotifier memoDueNotifier = new PrintingNotifier(Console.Out);
21              MemoChecker chechker = new MemoChecker(memos, memoDueNotifier);
22              chechker.CheckNow();
23               */
24 
25               // 以IoC依赖注入方式创建对象
26               using  (var container  =  RegisterContainer())
27                  container.Resolve < MemoChecker > ().CheckNow();
28 
29              Console.ReadKey();
30          }
31 
32           ///   <summary>
33           ///  注册组件容器
34           ///   </summary>
35           ///   <returns></returns>
36           private   static  IContainer RegisterContainer()
37          {
38 
39               // 使用了 Autofac 的依赖注入后的方式
40               // 创建构造器
41              var builder  =   new  ContainerBuilder();
42 
43               // 登记MemoChecker组件
44              builder.Register(c  =>   new  MemoChecker(
45                  c.Resolve < IQueryable < Memo >> (),
46                  c.Resolve < IMemoDueNotifier > ())
47              );
48 
49               // 登记PrintingNotifier组件
50              builder.Register(c  =>   new  PrintingNotifier(
51                  c.Resolve < TextWriter > ())
52              ).As < IMemoDueNotifier > ();
53 
54               // 注册实例对象
55              builder.RegisterInstance(memos);
56              builder.RegisterInstance(Console.Out).As < TextWriter > ().ExternallyOwned();
57 
58               // 检查依赖关系生成容器
59               return  builder.Build();
60          }
61      }
62  }

　　完成了上面这个范例你有些茫然，为什么我们要用如此复杂的方式来获取对象呢？它为我们带来了什么便利呢？这个问题很纠结（其实我第一看设计模式的时候也有这种问题）。

引用官方的一段话：

IoC带给了我们一种新的方式解藕在客户代码中直接new的对象，同时它遵循面向接口编程的OO原理，让我们对接口操作而不对具体实现操作，当我们面对程序的变化的时候，就可以增加新的类，然后注册到系统中，而无须修改原来的类和客户代码中所有对该类的引用，这同时也符合了开闭原则。

说了这么多官话，简单的来说就是让我们不需要在程序发生变化的时候，查找每个引用，然后Ctrl+V,Ctrl+C的重复替换，同样我们也可以动态的改变程序的具体实现方式，就拿我们这个例子来说，我们可以实现个继承自IMemoDueNotifier接口的ASP.NET 通知者，这样我们就可以将结果输出到WEB上了。

明天再写计算器的讲解吧，在下一篇中将使用配置文件来进行注册，而不象本篇完全的代码注册。