SCSF 系列：Smart Client Software Factory 启动过程详解

应网友要求，结合参考实现（BankBranchWorkbench）写一篇关于 SCSF 内部工作原理的文章，需要读者有 SCSF 基础。基本概念和基本理念后面相关文章介绍。

SCSF 自动为我们建立了 Shell 项目。该项目的 ShellApplication 是SCSF 应用的入口程序，该类继承自 SmartClientApplication<TWorkItem, TShell> ，TWorkItem 是要指定的 root workitem ，TShell 是主窗体。

该类的 Main 方法通过 new ShellApplication().Run(); 启动应用。Run（） 在父类 CabApplication 中实现，定义了 SCSF 的启动流程：

1 public void Run()
2 {
3     RegisterUnhandledExceptionHandler();
4     Builder builder = CreateBuilder();
5     AddBuilderStrategies(builder);
6     CreateRootWorkItem(builder); 
7 
8     IVisualizer visualizer = CreateVisualizer();
9     if (visualizer != null)
10         visualizer.Initialize(rootWorkItem, builder); 
11 
12     AddRequiredServices();
13     AddConfiguredServices();
14     AddServices();
15     AuthenticateUser();
16     ProcessShellAssembly();
17     rootWorkItem.BuildUp();
18     LoadModules();
19     rootWorkItem.FinishInitialization(); 
20 
21     rootWorkItem.Run();
22     Start(); 
23 
24     rootWorkItem.Dispose();
25     if (visualizer != null)
26         visualizer.Dispose();
27 } 
28 

其中核心流程有：

1. 首先创建 Builder builder = CreateBuilder(); 

CreaterBuilder（）方法注册了 RootWorkItemInitializationStrategy ，EventBrokerStrategy，CommandStrategy，ObjectBuiltNotificationStrategy 总共四个策略，同时还添加了三个 Policy ：SingletonPolicy，BuilderTraceSourcePolicy，ObjectBuiltNotificationPolicy 。

CreaterBuilder（） 一般使用 builder.Strategies.AddNew 方法利用 ObjectBuilder 构建策略对象 （例如：builder.Strategies.AddNew<EventBrokerStrategy>(BuilderStage.Initialization)）。

2. 子类可以通过重写 protected virtual void AddBuilderStrategies(Builder builder) 来给 ObjectBuilder 添加其他构建策略（在构建对象或者销毁对象时执行的操作）。

3. 初始化 RootWorkItem

这些准备工作做完后，第一件事是创建 RootWorkItem 。RootWorkItem 是通过 CreateRootWorkItem(builder) 完成的，以前面创建的 builder 作为参数：protected internal void InitializeRootWorkItem(Builder builder)。

InitializeRootWorkItem 中首先初始化 RootWorkItem 相关的 Builder 和 Locator （这两个都是 ObjectBuilder 的组件，用与对象创建和依赖注入）:

this.builder = builder;
this.locator = new Locator();

其次对 rootWorkItem 进行初始化，主要执行以下三个方法：

InitializeFields()：设置或初始化 ObjectBuilder 相关的对象： Builder，Locator，ObjectBuiltNotificationPolicy，还有 workItem 的状态。

InitializeState()：通过 Guid 生成本 workItem 实例的 ID （ID = Guid.NewGuid().ToString();）；

InitializeCollectionFacades()：初始化管理 SCSF 核心组件的对象管理集合： ServiceCollection，commandCollection，workItemCollection，workspaceCollection，itemsCollection，smartPartCollection，eventTopicCollection，uiExtensionSiteCollection 。

RootWorkItem 构建完成后有一个可选的过程是创建 IVisualizer （用于在运行时查看 WorkItem 的状态）：

1 IVisualizer visualizer = CreateVisualizer();
2 if (visualizer != null)
3     visualizer.Initialize(rootWorkItem, builder);

4. 添加服务：

AddRequiredServices() 方法添加的服务有：TraceSourceCatalogService，WorkItemExtensionService，WorkItemTypeCatalogService，SimpleWorkItemActivationService，WindowsPrincipalAuthenticationService，ModuleLoaderService，FileCatalogModuleEnumerator，DataProtectionCryptographyService，CommandAdapterMapService，UIElementAdapterFactoryCatalog 。

AddConfiguredServices() 添加在配置文件中配置的服务，也就是运行我们通过配置的方式决定在 SCSF 框架启动时加载额外服务（Services）。

AddServices() 在 CabApplication 中是一个空的虚拟方法，允许我们创建 CabApplication 的子类来重写该方法以添加需要的 Services 。

5. 验证用户

通过获取在启动过程中注册的 IAuthenticationService 服务来进行用户验证（ObjectBuilder 的具体应用）：

1 private void AuthenticateUser()
2 {
3     IAuthenticationService auth = rootWorkItem.Services.Get<IAuthenticationService>(true); 
4     auth.Authenticate();
5 }

6. 处理 Shell 程序集（可执行的 Shell Assembly）

1 private void ProcessShellAssembly()
2 {
3     IModuleLoaderService loader = rootWorkItem.Services.Get<IModuleLoaderService>(true);
4     Assembly assembly = Assembly.GetEntryAssembly(); 
5 
6     if (assembly != null)
7         loader.Load(rootWorkItem, assembly);
8 } 
9 

通过 ObjectBuilder 获取已注册的 IModuleLoaderService （默认的是 Microsoft.Practices.CompositeUI.Services.ModuleLoaderService），调用 ModuleLoaderService 的 Load 方法来通过SCSF Attribute（反射和特性）结合 ObjectBuilder 来加载 SCSF 核心组件，包括 Services、 Command 、 SmartParts、UIElement、workspace、Event Broker、State 等，这些属性（Attribute）主要有：ServiceAttribute，ServiceDependencyAttribute，SmartPartAttribute，CommandHandlerAttribute，EventPublicationAttribute，EventSubscriptionAttribute，ModuleDependencyAttribute，StateChangedAttribute，RootWorkItemExtensionAttribute，OptionalDependencyAttribute，TraceSourceAttribute，ComponentDependencyAttribute，WorkItemExtensionAttribute ，以后有时间会专门介绍这些属性的使用。

7. 构建 RootWorkItem （rootWorkItem.BuildUp()）

RootWorkItem 通过 builder.BuildUp(locator, type, temporaryID, this, policies) 方法使用 ObjectBuilder 进行构建，前面介绍过 CabApplication 在 CreaterBuilder（） 中注册了构建策略 RootWorkItemInitializationStrategy： builder.Strategies.Add(new RootWorkItemInitializationStrategy(this.OnRootWorkItemInitialized), BuilderStage.Initialization)，该语句表明在创建 RootWorkItem 时 ObjectBuilder 会执行该策略并调用本类（CabApplication 或者重载的子类）的 OnRootWorkItemInitialized 方法：protected virtual void OnRootWorkItemInitialized()。CabShellApplication （CabApplication 的子类） 重写了该方法：

1 protected sealed override void OnRootWorkItemInitialized()
2 {
3     BeforeShellCreated();
4     shell = RootWorkItem.Items.AddNew<TShell>();
5     AfterShellCreated();
6 }

其中 RootWorkItem.Items.AddNew<TShell>() 语句创建了新的 TShell 主窗体对象（通过 ObjectBuilder 构建）并加入到 RootWorkItem 的 Items 集合中。

8. 通过配置加载模块（LoadModules()）

RootWorkItem 构建完成后，SCSF 会根据 IModuleEnumerator 服务来枚举可以加载的模块（确定需要加载哪些模块），SCSF 中提供了两个 IModuleEnumerator 服务：FileCatalogModuleEnumerator（在配置文件中指明要加载哪些模块，默认的配置文件是 ProfileCatalog.xml ）和 ReflectionModuleEnumerator（利用反射和 ModuleAttribute 来确定需要加载哪些模块）。同时 SCSF 的Package Guidance 为我们提供了一个 XmlStreamDependentModuleEnumerator ，用于从 Xml Stream 中确定需要加载哪些模块，这个可以用在通过 Web Service 将服务器上的配置发送到客户端的情况。

典型的配置文件示例 ProfileCatalog.xml ：

<SolutionProfile xmlns="http://schemas.microsoft.com/pag/cab-profile/2.0%22>
  <Section Name="Infrastructure">
    <Modules>
        <ModuleInfo AssemblyFile="GlobalBank.Support.Module.dll" /> 
        <ModuleInfo AssemblyFile="GlobalBank.Infrastructure.Module.dll" />
    </Modules>
  </Section>
  <Section Name="BranchSystems">
    <Dependencies>
      <Dependency Name="Infrastructure" />
    </Dependencies>
    <Modules>
      <ModuleInfo AssemblyFile="GlobalBank.BranchSystems.Layout.dll" Name="BranchSystems.Layout"/>
      <ModuleInfo AssemblyFile="GlobalBank.BranchSystems.Module.dll">
        <Dependencies>
          <Dependency Name="BranchSystems.Layout" />
        </Dependencies>
        <Roles>
          <Role Allow="Greeter"/>
          <Role Allow="Officer"/>
          <Role Allow="BranchManager"/>
        </Roles>
      </ModuleInfo>
    </Modules>
  </Section>
  <Section Name="LinesOfBusiness">
    <Dependencies>
      <Dependency Name="Infrastructure" />
      <Dependency Name="BranchSystems" />
    </Dependencies>
    <Modules>
      <ModuleInfo AssemblyFile="GlobalBank.BasicAccounts.Module.dll">
        <Roles>
          <Role Allow="Officer"/>
          <Role Allow="BranchManager"/>
        </Roles>
      </ModuleInfo>
      <ModuleInfo AssemblyFile="GlobalBank.CreditCardAccounts.Module.dll">
        <Roles>
          <Role Allow="Officer"/>
          <Role Allow="BranchManager"/>
        </Roles>
      </ModuleInfo>
    </Modules>
  </Section>
</SolutionProfile> 

确定要加载那些模块后，就会执行上面 “6. 处理 Shell 程序集”中的过程，利用注册的 IModuleLoaderService 加载模块。SCSF 规定每个 Module 程序集都有一个继承自 ModuleInit 的子类，IModuleLoaderService  会在加载完该 Module 后自动调用其 void Load() 方法，这里是 SCSF 为我们通过的接入点，我们应该在 void Load() 方法中初始化本模块。具体应该初始化什么以后介绍。 

9. 完成对 RootWorkItem 的创建（rootWorkItem.FinishInitialization()） 
主要是处理 workItem 扩展（以后介绍），并触发创建完成事件：

1 protected internal void FinishInitialization()
2 {
3     IWorkItemExtensionService extensionsService = Services.Get<IWorkItemExtensionService>();
4     if (extensionsService != null)
5         extensionsService.InitializeExtensions(this); 
6 
7     OnInitialized();
8 } 
9 

同时 WorkItem 的 public void InitializeWorkItem() 是一个注入方法，有[InjectionMethod]属性标记，该方法执行时除了执行上面 rootworkItem中的初始化过程外，还会调用 InitializeServices 方法，该方法在 CabApplication 中是空方法，CabApplication 子类可以重写 protected virtual void InitializeServices() 方法，用于在 WorkItem 初始化时加载其他需要的服务。

10. 执行 rootWorkItem 的 run 方法 rootWorkItem.Run();

WorkItem 的 Run 方法直接调用 protected virtual void OnRunStarted() 方法：

1 public void Run()
2 {
3     OnRunStarted();
4 }

OnRunStarted 方法触发 RunStarted 事件（public event EventHandler RunStarted）

1 protected virtual void OnRunStarted()
2 {
3     if (this.RunStarted != null)
4     {
5         this.RunStarted(this, EventArgs.Empty);
6     } 
7 
8     if (traceSource != null)
9         traceSource.TraceInformation(String.Format(
10             CultureInfo.CurrentCulture,
11                   Properties.Resources.TraceWorkItemRunStarted, ID));
12 } 
13 

因此我们可以通过注册 RunStarted 事件或者在 WorkItem 子类中重写 OnRunStarted() 虚方法以便在 SCSF 启动过程中执行自己的操作，这是 SCSF 的又一扩展点。

11. 启动应用 Start()

CabApplication 中的 Start 是一个抽象方法：protected abstract void Start();

子类 FormShellApplication（public abstract class FormShellApplication<TWorkItem, TShell> : WindowsFormsApplication<TWorkItem, TShell>） 重写了Start ：

1 protected override void Start()
2 {
3     Application.Run(Shell);
4 }

很简单，这时主窗体就显示出来了，以后的整个操作就是通过用户交互来触发了。

以上只是简单的介绍了一下 SCSF 的启动流程，还有很多细节后面的文章会接受。

 转载：FLYabroad.NET  孙洪亮