技巧：使用可扩展对象模式扩展HttpApplication

概述

  HttpApplication对象对于做ASP.NET开发的朋友，我想没有人不熟悉它。在ASP.NET开发中，经常避免不了要在HttpApplication中执行一些操作，如使用了ASP.NET MVC框架，就会在Application_Start 事件中避免不了这样的路由规则配置代码：

1. protected void Application_Start()
2. {
3.     RouteTable.Routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
5.     RouteTable.Routes.MapRoute(
6.         "Default",                                              // Route name
7.         "{controller}/{action}/{id}",                           // URL with parameters
8.         new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
9.     );
10. }

复制代码

如果仅仅是这一条，看起来倒不觉的有什么问题，但如果同时在应用程序中使用了工作流，又避免不了在Application_Start出现启动工作流运行时的代码：

1. protected void Application_Start()
2. {
3.     // 注册路由规则
4.     RouteTable.Routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
5.     RouteTable.Routes.MapRoute(
6.         "Default",                                              // Route name
7.         "{controller}/{action}/{id}",                           // URL with parameters
8.         new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
9.     );
11.     // 启动工作流
12.     WorkflowRuntime workflowRuntime = new WorkflowRuntime("workflowServicesConfig");
13.     ExternalDataExchangeService externalDataExchangeService = new ExternalDataExchangeService();
14.     workflowRuntime.AddService(externalDataExchangeService);
15.     workflowRuntime.StartRuntime();
16. }

复制代码

试想一下，现在我们仅仅是有了ASP.NET MVC路由规则的配置、WF运行时的启动，如果在应用程序中使用某种DI框架，如微软的Unity，是不是又避免不了要出现这样的容器初始化代码呢？

1. protected void Application_Start()
2. {
3.     // 注册路由规则
4.     RouteTable.Routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
5.     RouteTable.Routes.MapRoute(
6.         "Default",                                              // Route name
7.         "{controller}/{action}/{id}",                           // URL with parameters
8.         new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
9.     );
11.     // 启动工作流
12.     WorkflowRuntime workflowRuntime = new WorkflowRuntime("workflowServicesConfig");
13.     ExternalDataExchangeService externalDataExchangeService = new ExternalDataExchangeService();
14.     workflowRuntime.AddService(externalDataExchangeService);
15.     workflowRuntime.StartRuntime();
17.     // 初始化DI容器
18.     IContainerContext repositoryContainer = ContainerManager.GetContainer("repositoryContainer");
19.     repositoryContainer.Initialize();
20. }

复制代码

再看看Application_Start事件中的代码，有ASP.NET MVC的工作，有WF的工作，也有Unity的工作，不知道将来还会有什么？这些原本互相之间没有任何联系的代码，现在却同时堆在了一起，当每一部分（或者说每一个框架）变化的时候，都会涉及到Application_Start中代码的修改，显然违反了OCP原则。那么有没有一种机制，让这些互不相干的模块之间互相独立，各自发生变化时不影响对HttpApplication？此时我们就需要对HttpApplication进行扩展，提供一个扩展点，让其他模块的程序附加到HttpApplication上面。
可扩展对象模式

我们知道WCF提供了非常完美的扩展机制，几乎在服务执行过程中的每一个环节上都提供有扩展点，如ServiceHostBase、OperationContext、InstanceContext、IContextChannel，这些对象都属于可扩展对象，它们都通过Extensions属性获取用于所有扩展的集合。我们能不能使用这种方式对HttpApplication也进行扩展呢，答案自然是肯定的。查阅一下MSDN就会知道在System.ServiceModel命名空间下面提供了这样的一组接口：IExtensibleObject、IExtension和IExtensionCollection，这是可扩展对象模式中最重要的三个接口，也只有这三个接口。
IExtensibleObject自然是定义了可扩展对象，即我们要对谁进行扩展，它的定义非常简单，仅仅是提供了一个只读的属性Extensions，用来提供所有扩展对象的集合，如下代码所示：

1. public interface IExtensibleObject<T> where T : IExtensibleObject<T>
2. {
3.     IExtensionCollection<T> Extensions { get; }
4. }

复制代码

IExtension定义了扩展对象的契约，使对象可以通过聚合扩展另一个对象（此处的另一个对象，就是指上面所讲的扩展宿主IExtensibleObject），在IExtension中定义了两个非常重要的方法Attach和Detach方法，分别用来提供聚合或解聚的通知。

1. public interface IExtension<T> where T : IExtensibleObject<T>
2. {
3.     void Attach(T owner);
4.     void Detach(T owner);
5. }

复制代码

当一个扩展对象IExtension附加到可扩展对象的扩展集合中时，它的Attach方法将会被调用；反之如果从集合中移除一个扩展对象时，它的Detach方法会被调用。这一点我们可以通过Reflector来得到验证，如下代码所示：

1. protected override void InsertItem(int index, IExtension<T> item)
2. {
3.     lock (base.SyncRoot)
4.     {
5.         item.Attach(this.owner);
6.         base.InsertItem(index, item);
7.     }
8. }
10. protected override void RemoveItem(int index)
11. {
12.     lock (base.SyncRoot)
13.     {
14.         base.Items[index].Detach(this.owner);
15.         base.RemoveItem(index);
16.     }
17. }

复制代码

最后一个接口是IExtensionCollection，它是IExtension对象的集合。
对HttpApplication进行扩展

下面我们就看一下如何使用可扩展对象模式对HttpApplication进行扩展，首先定义可扩展对象，让ExtensibleHttpApplication派生于HttpApplication，并实现了IExtensibleObject接口，泛型的参数类型就是它自身，如下代码所示：

1. public class ExtensibleHttpApplication : HttpApplication,
2.     IExtensibleObject<ExtensibleHttpApplication>
3. {
4.     private IExtensionCollection<ExtensibleHttpApplication> _extensions;
5.    
6.     public ExtensibleHttpApplication()
7.     {
8.         this._extensions = new ExtensionCollection<ExtensibleHttpApplication>(this);
9.     }
11.     public IExtensionCollection<ExtensibleHttpApplication> Extensions
12.     {
13.         get
14.         {
15.             return this._extensions;
16.         }
17.     }
18. }

复制代码

有了可扩展的HttpApplication之后，需要在HttpApplication中实现任何功能，都可以作为一个扩展附加到ExtensibleHttpApplication上去，如实现ASP.NET MVC路由，可以定义一个如下代码所示的扩展对象：

1. public class MvcHttpApplication : IExtension<ExtensibleHttpApplication>
2. {
3.     public void Attach(ExtensibleHttpApplication owner)
4.     {
5.         RouteTable.Routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
7.         RouteTable.Routes.MapRoute(
8.             "Default",                                              // Route name
9.             "{controller}/{action}/{id}",                           // URL with parameters
10.             new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
11.         );
12.     }
14.     public void Detach(ExtensibleHttpApplication owner)
15.     {
16.         //nothing
17.     }
18. }

复制代码

同样如果要在HttpApplication中启动Workflow，可以再针对Workflow定义一个扩展对象，如下示例代码所示：

1. public class WorkflowHttpApplication : IExtension<ExtensibleHttpApplication>
2. {
3.     private WorkflowRuntime workflowRuntime;
4.     public void Attach(ExtensibleHttpApplication owner)
5.     {
6.         workflowRuntime = new WorkflowRuntime("workflowServicesConfig");
7.         ExternalDataExchangeService externalDataExchangeService = new ExternalDataExchangeService();
8.         workflowRuntime.AddService(externalDataExchangeService);
9.         workflowRuntime.StartRuntime();
10.     }
12.     public void Detach(ExtensibleHttpApplication owner)
13.     {
14.         workflowRuntime.StopRuntime();
15.     }
16. }

复制代码

我们已经定义好了相应的扩展对象，只需要在相应的HttpApplication把扩展对象附加到ExtensibleHttpApplication上即可，修改Global.asax中的代码如下所示：

1. public class MvcApplication : ExtensibleHttpApplication
2. {
3.     protected void Application_Start()
4.     {
5.         this.Extensions.Add(new MvcHttpApplication());
6.         this.Extensions.Add(new WorkflowHttpApplication());
7.     }
8. }

复制代码

现在代码是不是看起来优雅多了？现在如果要在Application_Start中，添加另外一些执行代码，只需要编写相应的扩展对象，并将其添加到Extension集合中即可。也许有朋友会问，这样每添加一些新的代码，还是要修改Application_Start中的代码啊？别忘了，可以通过配置可以解决这个问题，WCF中的扩展不也是可以采用配置方式实现，不是吗？同样，如果我们需要在Application_End事件中释放某些对象，可以直接从扩展集合中移除它，此时将会调用它的Detach方法。
总结

本文介绍了如何使用WCF中提供的可扩展对象模式扩展HttpApplication，事实上可扩展对象模式的作用远不在此，它可以扩展.NET类库中任何我们想对其进行扩展的对象，或者是一个自定义的类型，都可以使用可扩展对象模式对其进行扩展。
特别鸣谢：Jesse Qu
注1：由于TerryLee最近一段时间忙于别的事务，无暇顾及Blog，所以有大量的评论和E-mail都没能回复，请大家见谅。
注2：由TerryLee撰写的《Silverlight 2完美征程》一书，即将于本月底上市，敬请期待，详情大家可以访问本书官方网站http://www.dotneteye.cn/silverlight了解。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！