SCSF 系列：Smart Client Software Factory 与 ObjectBuilder

【FLYabroad】ObjectBuilder 简介，SCSF 对 ObjectBuilder 的使用和扩展，SCSF 与控制反转（IOC）。

上一篇：Smart Client Software Factory 启动过程详解 介绍了 SCSF 的启动过程，启动的核心工作就是通过 ObjectBuilder 组件准备整个职能客户端运行环境，因此第一步就是建立一个 Microsoft.Practices.ObjectBuilder.Builder ，SCSF 的整个依赖注入（DI）就基于 ObjectBuilder 。

Object Builder 原先是微软P&P团队为 CAB（Composite UI Application Block，是 SCSF 的核心部分，本系列的大部分文章都是介绍 CAB 的） 建立的，后来几乎在所有P&P项目中使用，包括 Enterprise Libaray ，Web Client Software Factory，WebService Software Factory 等。本文说的 Object Builder 是 ObjectBuilder 1【FLYabroad注】，P&P 开发的 IOC 容器 Unity 是基于 ObjectBuilder 2 的（对 ObjectBuilder 1 进行了改进和加强） 。

通过名字我们大概可以看出 ObjectBuilder 是用来创建对象的，就像一个对象工厂，而这个工厂几乎可以制造任何对象，并且除了创建对象外还负责对象的生命周期管理（例如合适销毁，如何销毁等）。

为什么需要 ObjectBuilder ？原因说来也简单，一个对象要使用首先需要被创建（并初始化），传统的通过 new 方式来构造对象的方式是程序强耦合的罪魁：

• 首先 new 是具体化的，我们必须在程序中硬编码要 new 的对象，而面向对象的最佳实践是面向抽象；
• 其次，要 new 一个对象，new 的一方必须要引入被 new 一方的程序集依赖和命名空间，这就是强耦合；例如我们要构造 Builder 对象，必须先引入 ObjectBuilder.dll 程序集，同时 using Microsoft.Practices.ObjectBuilder.Builder ；
• 再次，我们所说的多态，如果只通过 new 来构造对象，有时多态的能力就会大打折扣；

要想构造松散耦合的系统，抽象对象构造过程是必须的。这一点在 IOC 模式中可以明显的体现出来，IOC 容器为我们提供了对象生命周期管理（从创建到销毁）的场所，它允许我们把对象构造的过程集中在容器中，可以通过配置或者元数据发现（Attribute）等方式动态的构造对象，并且容器提供强大的灵活性来适应对象的生命周期管理功能。这样对于我们构建松散耦合的系统，构造插件式系统简直太有用了。

如果希望程序能够动态的、抽象的构造对象就需要类似 ObjectBuilder 这样的组件或者服务（Sping 中的 ObjectFactory 也是完成这种工作的）。ObjectBuilder 是一个比较底层的对象创建组件，是 IOC 容器的基础。ObjectBuilder 就是为了简化和标准化这些工作的。

对于一般程序员来说我们直接使用 ObjectBuilder 的机会不多，同时网上也有很多不错的介绍 ObjectBuilder 的文章，这里我们不去过多的关注 OB 的工作原理和流程，而是系统通过 OB 在 SCSF 中的使用，更加透彻的理解上一篇我们讲的 SCSF 的工作原理。

一、 ObjectBuilder 的逻辑架构

ObjectBuilder 的核心概念由 4 个组件组成，BuilderContext（IBuilderContext） 是一个包含若干 Strategies （IBuilderStrategy）、Polices（IBuilderPolicy）、Locator（IReadableLocator，IReadWriteLocator）。

BuilderContext 维护了一个策略链（strategy chain），对象在经过策略链里的所有策略构造后才最终被创建；

Strategy 负责对象创建的一个方面，这些方面主要包括：Pre-Creation Strategy（对象被创建前），Creation Strategy（对象创建），Initialization Strategy （对象初始化），Post-Initialization Strategy （对象初始化完成后）。每个方面中又会有一或多个具体的策略类。例如 SingletonStrategy （属于 Pre-Creation Strategy）策略用于告诉 ObjectBuilder 应该创建单例对象。具体的 Strategy 通过 object BuildUp(IBuilderContext context, Type typeToBuild, object existing, string idToBuild) 构造对象，通过 object TearDown(IBuilderContext context, object item) 销毁对象。

Policy 的作用主要是告诉 Strategy 对不同的对象进行构建可能要进行不同操作 。Policy 与 Strategy 通常成对出现，例如 ISingletonPolicy 是配合 SingletonStrategy 在 CreationStrategy 中用的，只有那些被指明了 IsSingleton == true 属性的对象才使用 SingletonStrategy  。也就是 Policy 具体规定了对应 Strategy 的执行场合。

Locator 对象定位器，基本上是一个键值对的容器，分为 ReadOnlyLocator 和 ReadWriteLocator ，我们可以从 ReadOnlyLocator 获取对象，可以向 ReadWriteLocator  中添加、删除对象，当然也可以获取对象。

ILifetimeContainer 是一个生命周期容器，ObjectBuilder 通过 ILifetimeContainer 跟踪对象的生命周期，ILifetimeContainer 最主要的是实现了 IDisposable ，当 Container disposed 的时候，整个容器中的对象都将 disposed。

二、 SCSF 中主要的 Strategy 和 Policy

上一篇 中就介绍过 CreaterBuilder（）方法注册了四个策略： EventBrokerStrategy，CommandStrategy，RootWorkItemInitializationStrategy ，ObjectBuiltNotificationStrategy 和三个缺省 Policy ：SingletonPolicy，BuilderTraceSourcePolicy，ObjectBuiltNotificationPolicy 。

class CabApplication<TWorkItem> 中 Run() 最开始要做的就是为整个 SCSF 准备 Builder ：

 1 private Builder CreateBuilder()
 2 {
 3     Builder builder = new Builder(); 
 4     builder.Strategies.AddNew<EventBrokerStrategy>(BuilderStage.Initialization);
 5     builder.Strategies.AddNew<CommandStrategy>(BuilderStage.Initialization);
 6     builder.Strategies.Add(new RootWorkItemInitializationStrategy(this.OnRootWorkItemInitialized), BuilderStage.Initialization);
 7     builder.Strategies.AddNew<ObjectBuiltNotificationStrategy>(BuilderStage.PostInitialization); 
 8 
 9 builder.Policies.SetDefault<ISingletonPolicy>(new SingletonPolicy(true));
10     builder.Policies.SetDefault<IBuilderTracePolicy>(new BuilderTraceSourcePolicy(new TraceSource("Microsoft.Practices.ObjectBuilder")));
11     builder.Policies.SetDefault<ObjectBuiltNotificationPolicy>(new ObjectBuiltNotificationPolicy()); 
12 
13     return builder;
14 } 

这四个策略（Strategy）都是由 SCSF（CAB） 提供的（也就是 CAB 扩展了 ObjectBuilder），三个 Policy 中 ObjectBuiltNotificationPolicy 是 CAB 提供的。下面我们重点介绍 SCSF 提供的这些 BuilderStrategies ，对应的源代码在 Microsoft.Practices.CompositeUI.BuilderStrategies 命名空间下。

1. EventBrokerStrategy

EventBrokerStrategy 应用于初始化阶段（BuilderStage.Initialization），是我们理解 SCSF EventBroker （EventPublicationAttribute 和 EventSubscriptionAttribute）的关键。

 1 //EventBrokerStrategy 类的 BuildUp 方法
 2 public override object BuildUp(IBuilderContext context, Type t, object existing, string id)
 3 {
 4     WorkItem workItem = GetWorkItem(context, existing); 
 5 
 6     if (workItem != null)
 7         EventInspector.Register(existing, workItem); 
 8 
 9     return base.BuildUp(context, t, existing, id);
10 } 

EventBrokerStrategy 告诉 ObjectBuilder 在构建过程中调用 EventInspector.Register(existing, workItem);（在销毁过程中执行相反操作 EventInspector.Unregister(item, workItem)），EventInspector.Register(existing, workItem) 中执行两个操作：

1 ProcessPublishers(item, item.GetType(), workItem, true); //class EventInspector
2 ProcessSubscribers(item, item.GetType(), workItem, true); //class EventInspector

ProcessPublishers 检查 item 中的 Event 上是否标有 EventPublicationAttribute 属性，如果有就注册到 EventTopic 的 Publication 中去：

1 topic.AddPublication(item, info.Name, workItem, attr.Scope); //class EventInspector 

ProcessSubscribers 检查相应的 item 中的成员上是否有 EventSubscriptionAttribute 属性，如果有就把它注册到对应得 Subscription 中去：

1 topic.AddSubscription(item, info.Name, paramTypes, workItem, attr.Thread); //class EventInspector 

【FLYabroad】也就是说，SCSF 启动过程中，ObjectBuilder 会到被创建的对象上去找标有 EventPublicationAttribute 和 EventSubscriptionAttribute 的事件和方法，并通过 topic, 和 PublicationScope 把对应的事件发布和接受者动态的关联起来，放到 WorkItem 的 EventTopic 集合中。

2. CommandStrategy

CommandStrategy 与 EventBrokerStrategy 类似，主要负责查看构建的 item 的方法上是否有 CommandHandlerAttribute ，如果有就通过 Delegate 机制构建该对象并添加到当前 workItem 的 Commands 集合中。

3. RootWorkItemInitializationStrategy 

RootWorkItemInitializationStrategy 在 BuilderStage.Initialization 阶段调用，并且将 RootWorkItemInitializationCallback 绑定到了 CabApplication 的 OnRootWorkItemInitialized 方法：

1 //CabApplicatioin 类中的 CreatBuilder 方法中
2 builder.Strategies.Add(new RootWorkItemInitializationStrategy(this.OnRootWorkItemInitialized), BuilderStage.Initialization);
3 

整个 SCSF 应用有且只有一个 RootWorkItem ，ObjectBuilder 在创建 RootWorkItem 时通过调用 OnRootWorkItemInitialized 方法，CabApplication 中默认的 OnRootWorkItemInitialized 方法是一个空方法，子类 CabShellApplication 中重写了该方法，主要功能是将主窗体 TShell 加入到 RootWorkItem 中：

1 //CabShellApplication 类重写了父类 CabApplication 空的 OnRootWorkItemInitialized 方法
2 protected sealed override void OnRootWorkItemInitialized()
3 {
4     BeforeShellCreated();
5     shell = RootWorkItem.Items.AddNew<TShell>(); //将主窗口注册到 RootWorkItem 中
6     AfterShellCreated();
7 } 
8 

【FLYabroad】RootWorkItemInitializationStrategy 在构建 RootWorkItem 的过程中被使用，主要任务是将主窗口 TShell 注册到 RootWorkItem 中。

4. ObjectBuiltNotificationStrategy

ObjectBuiltNotificationStrategy 处理初始化完成后的事情（BuilderStage.PostInitialization），主要作用是在对象创建完成后通知相应的 workItem:

ObjectBuilder 在构造 RootWorkItem 对象过程中会调用 ObjectBuiltNotificationStrategy 的 BuildUp 方法，ObjectBuiltNotificationStrategy 又会调用 ObjectBuiltNotificationPolicy（在CreateBuilder（）中注册）的 policy.AddedDelegates.TryGetValue(workItem, out notification) 获取 notification 代理（ObjectBuiltNotificationPolicy.ItemNotification  类型）并执行：

 1 //ObjectBuiltNotificationStrategy 类中的 BuildUp 方法
 2 public override object BuildUp(IBuilderContext context, Type typeToBuild, object existing, string idToBuild)
 3 {
 4     WorkItem workItem = context.Locator.Get<WorkItem>(new DependencyResolutionLocatorKey(typeof(WorkItem), null));
 5     ObjectBuiltNotificationPolicy.ItemNotification notification; 
 6 
 7     if (policy == null)
 8         policy = context.Policies.Get<ObjectBuiltNotificationPolicy>(null, null); 
 9 
10     if (workItem != null && !Object.ReferenceEquals(workItem, existing) && policy.AddedDelegates.TryGetValue(workItem, out notification))
11         notification(existing); 
12 
13     return base.BuildUp(context, typeToBuild, existing, idToBuild);
14 } 
15 

ObjectBuiltNotificationStrategy 的 AddedDelegates 是在 WorkItem 初始化时赋值的（在InitializeFields()中注册 OnObjectAdded）：

 1 //WorkItem 的 InitializeFields() 方法中 
 2 …………………… 
 3 ObjectBuiltNotificationPolicy policy = builder.Policies.Get<ObjectBuiltNotificationPolicy>(null, null); 
 4 
 5 if (policy != null)
 6 {
 7     policy.AddedDelegates[this] = new ObjectBuiltNotificationPolicy.ItemNotification(OnObjectAdded);
 8     policy.RemovedDelegates[this] = new ObjectBuiltNotificationPolicy.ItemNotification(OnObjectRemoved);
 9 } 
10 ……………………………
11 

WorkItem 中的 internal event EventHandler> ObjectAdded;是在 ManagedObjectCollection 中注册：

 1 //ManagedObjectCollection 的构造函数
 2 public ManagedObjectCollection(ILifetimeContainer container, IReadWriteLocator locator,
 3             IBuilder<BuilderStage> builder, SearchMode searchMode, IndexerCreationDelegate indexerCreationDelegate,
 4             Predicate<TItem> filter, ManagedObjectCollection<TItem> parentCollection)
 5         {
 6             this.container = container;
 7             this.locator = locator;
 8             this.builder = builder;
 9             this.searchMode = searchMode;
10             this.indexerCreationDelegate = indexerCreationDelegate;
11             this.filter = filter;
12             this.parentCollection = parentCollection;
13             this.workItem = locator.Get<WorkItem>(new DependencyResolutionLocatorKey(typeof(WorkItem), null));
14 
15             if (this.workItem != null)
16             {
17                 this.workItem.ObjectAdded += new EventHandler<DataEventArgs<object>>(WorkItem_ItemAdded);
18                 this.workItem.ObjectRemoved += new EventHandler<DataEventArgs<object>>(WorkItem_ItemRemoved);
19             }
20         }

WorkItem 的 ObjectAdded 是 internal 的，只能在 CompositeUI.dll 内部使用，ManagedObjectCollection  将 WorkItem_ItemAdded（） 方法绑定到了 WorkItem 的 ObjectAdded 事件，而 WorkItem_ItemAdded 方法又会触发 ManagedObjectCollection 的 Added 事件（public event EventHandler<DataEventArgs<TItem>> Added）， SCSF 中 Added 事件默认没有注册，我们可以根据需要通过 ManagedObjectCollection 的 Added 事件处理对象构建完成后的事情。这又是 SCSF 的一个扩展点。

【FLYabroad】ObjectBuiltNotificationStrategy  结合 ObjectBuiltNotificationPolicy 允许我们通过在 ManagedObjectCollection 上注册 Added 事件来在对象构建完成后进行扩展处理。

三、SCSF 与控制反转（IOC\DI）

ObjectBuilder is a framework for creating dependency injection systems，SCSF 中使用 ObjectBuilder 来处理依赖注入。依赖注入的一般原理是，用一个容器来管理对象的生命周期，包需要的括创建、初始化、销毁，应用程序可以通过名字或者类型从容器中请求到需要的对象。

依赖注入常见的有三种：构造器注入、属性注入、方法注入。ObjectBuilder 通过 ConstructorReflectionStrategy, PropertyReflectionStrategy, MethodReflectionStrategy 三个策略来对应这三种注入方式。

ObjectBuilder 通过 Attribute 来判断具体进行哪种注入的，这些属性包括： [InjectionConstructor] ，[Dependency] ，[CreateNew] ，[MethodInjection] 。同时 SCSF 添加了自己的 Attribute ：[ServiceDependency] ， [ComponentDependency("id")]，[TraceSource]。

SCSF 内部只使用了 [InjectionConstructor]，[CreateNew]，[ServiceDependency]，[ComponentDependency("id")]和[TraceSource]。例如，GlobalBank.BasicAccounts.Module.PurchaseCDViewPresenter 的构造函数：

 1         [InjectionConstructor]
 2         public PurchaseCDViewPresenter
 3             (
 4             [ComponentDependency("QueueEntry")] QueueEntry queueEntry,
 5             [ServiceDependency] IQuoteService quoteService,
 6             [ServiceDependency] ICustomerAccountService customerAccountsService,
 7             [ServiceDependency] IAccountService accountService
 8             )
 9         {
10             _queueEntry = queueEntry;
11             _quoteService = quoteService;
12             _customerAccountsService = customerAccountsService;
13             _accountService = accountService;
14         }

[InjectionConstructor] 用于告诉 ObjectBuilder 使用该构造方法创建该对象（因为一个类可能有多个构造函数）。下一步 ObjectBuilder 要为该构造函数准备参数（如果构造函数有参数的话），ObjectBuilder 同样还是根据参数前的 Attribute 来判断如何构建这些参数：

如果是 [CreateNew]，则 ObjectBuilder 用相似的规则创建一个新的对象并传递给构造器；

如果是 [Dependency] ，OB 会在自己的对象容器中查找符合条件的已创建的对象；

如果是 [ServiceDependency]，表示该参数依赖于一个已注册到 workItem 中的 service ，需要到 workItem 中去查找；

如果是 [ComponentDependency("id")]，表示要到父 workItem 中找已经注册为“id”的对象；例如上例中 [ComponentDependency("QueueEntry")] QueueEntry queueEntry 的 queueEntry 就对应在 GlobalBank.BranchSystems.Module.CustomerWorkItemController 类的 Run() 方法中注册的 QueueEntry 实例：WorkItem.Items.Add(queueEntry, "QueueEntry");

[TraceSource] 表示依赖于跟踪源，SCSF 内部的 ClassNameTraceSourceAttribute 就是将类的全名作为一个跟踪源，我们平时使用的会比较少。

理解 SCSF 依赖注入的另一个要点是 SCSF 在 Microsoft.Practices.CompositeUI.Collections 提供的两个 Collections：

public class ManagedObjectCollection : ICollection, IEnumerable> 

public class ServiceCollection : ICollection, IEnumerable> 

它们在 WorkItem 类的 InitializeCollectionFacades() 方法中创建并初始化：

 1         private void InitializeCollectionFacades()
 2         {
 3             if (serviceCollection == null)
 4             {
 5                 serviceCollection = new ServiceCollection(lifetime, locator, builder,
 6                     parent == null ? null : parent.serviceCollection);
 7             }
 8 
 9             if (commandCollection == null)
10             {
11                 commandCollection = new ManagedObjectCollection<Command>(lifetime, locator, builder,
12                     SearchMode.Up, CreateCommand, null, parent == null ? null : parent.commandCollection);
13             }
14 
15             if (workItemCollection == null)
16             {
17                 workItemCollection = new ManagedObjectCollection<WorkItem>(lifetime, locator, builder,
18                     SearchMode.Local, null, null, parent == null ? null : parent.workItemCollection);
19             }
20 
21             if (workspaceCollection == null)
22             {
23                 workspaceCollection = new ManagedObjectCollection<IWorkspace>(lifetime, locator, builder,
24                     SearchMode.Up, null, null, parent == null ? null : parent.workspaceCollection);
25             }
26 
27             if (itemsCollection == null)
28             {
29                 itemsCollection = new ManagedObjectCollection<object>(lifetime, locator, builder,
30                     SearchMode.Local, null, null, parent == null ? null : parent.itemsCollection);
31             }
32 
33             if (smartPartCollection == null)
34             {
35                 smartPartCollection = new ManagedObjectCollection<object>(lifetime, locator, builder,
36                     SearchMode.Local, null, delegate(object obj)
37                         {
38                             return obj.GetType().GetCustomAttributes(typeof(SmartPartAttribute), true).Length > 0;
39                         },
40                     parent == null ? null : parent.smartPartCollection);
41             }
42 
43             if (eventTopicCollection == null)
44             {
45                 if (parent == null)
46                     eventTopicCollection = new ManagedObjectCollection<EventTopic>(lifetime, locator, builder,
47                         SearchMode.Local, CreateEventTopic, null, null);
48                 else
49                     eventTopicCollection = RootWorkItem.eventTopicCollection;
50             }
51 
52             if (uiExtensionSiteCollection == null)
53             {
54                 if (parent == null)
55                     uiExtensionSiteCollection = new UIExtensionSiteCollection(this);
56                 else
57                     uiExtensionSiteCollection = new UIExtensionSiteCollection(parent.uiExtensionSiteCollection);
58             }
59         }

ObjectBuilder （我们在使用 SCSF 时也是这样）一般是使用这些 Collections 的 Add、AddNew 方法将对象添加到集合中，通过 Get、FindByType

获得已经注册的对象，通过 Remove 从集合中删除对象。将在 WorkItem 中对这些 Collections 进行进一步介绍。