WCF技术剖析之七：如何实现WCF与EnterLib PIAB、Unity之间的集成

最新推荐文章于 2024-11-02 21:21:18 发布

weixin_33744141

最新推荐文章于 2024-11-02 21:21:18 发布

阅读量79

点赞数

文章标签：游戏

在这之前，我写过深入介绍MS EnterLib PIAB的文章（参阅《MS Enterprise Library Policy Injection Application Block 深入解析[总结篇]》），也写过WCF与PIAB的集成（参阅：《WCF后续之旅（8）：通过WCF Extension 实现与MS Enterprise Library Policy Injection Application Block 的集成》）、WCF与Unity的集成（参阅《WCF后续之旅（7）：通过WCF Extension实现和Enterprise Library Unity Container的集成》）以及Unity与PIAB的集成（参阅《Enterprise Library深入解析与灵活应用（1）：通过Unity Extension实现和Policy Injection Application Block的集成》、《Enterprise Library深入解析与灵活应用（7）：再谈PIAB与Unity之间的集成》）。由于部分实现时基于EnterLib、Unity前一个版本，在新的版本中（EnterLib V4.1与Unity 1.2）中，MS通过Unity对PIAB进行了重新设计与实现，所以我们很有必要重拾着这个话题，谈谈对于新的EnterLib和Unity，如何将PIAB和Unity集成到WCF之中。（Source Code从这里下载）

一、设计原理简述

在EnterLib中，PIAB与Unity的定位分别是轻量级的IoC Container（或者DI Container）与AOP框架。PIAB采用Method Call Interception的机制实现了策略的动态注入，其本身依赖于Interceptable对象的创建；UnityContainer建立在ObjectBuilder2之上，本质上是一个用于对象创建的容器。所以，我们可以通过UnityContainer按照PIAB的要求创建Interceptable对象，就能实现Unity与PIAB之间的集成（参阅《Enterprise Library深入解析与灵活应用（7）：再谈PIAB与Unity之间的集成》）。

Unity与WCF之间的集成，本质上就是让WCF使用UnityContainer进行服务实例的创建。而WCF框架内部，服务实例的创建同时一个特殊的对象——InstanceProvider。所以我们可以通过自定义InstanceProvider，并借助UnityContainer进行服务实例的提供，那么就能实现Unity与WCF两者之间的集成。所以，创建基于UnityContainer的InstanceProvider是关键。

二、创建基于UnityContainer的InstanceProvider：UnityInstanceProvider

在WCF框架内部，InstanceProvider用户进行服务实例的提供。所有的InstanceProvider实现了接口System.ServiceModel.Dispatcher.IInstanceProvider，下面是IInstanceProvider的定义。服务实例提供实现在GetInstance中，而ReleaseInstance用于实现对服务实例的释放和资源回收。

 
public interface IInstanceProvider 
{ 
    object GetInstance(InstanceContext instanceContext); 
    object GetInstance(InstanceContext instanceContext, Message message); 
    void ReleaseInstance(InstanceContext instanceContext, object instance); 
} 
  

我们现在的目的就是创建一个基于Unity的InstanceProvider，借助UnityContainer提供对GetInstance方法的实现，我姑且把这个自定义的InstanceProvider称为UnityInstanceProvider。在正式介绍UnityInstanceProvider的具体实现之前，我先介绍一个辅助类型的定义：UnityTypeMapping。

我们知道，UnityContainer采用动态注册接口或者抽象类于具体类型的匹配关系，使得我们可以利用UnityContaner实现基于接口或者抽象类的方式创建我们希望的具体类的对象。UnityTypeMapping用以描述类型的匹配，其定义如下。Type和Mapto分别表示相应的类型（接口或者抽象类）与被匹配的类型（具体类），Name则表示该Mapping Entry的名称（唯一标识）。

 
public class UnityTypeMapping 
{ 
    public Type Type 
    { get; set; } 
 
    public Type MapTo 
    { get; set; } 
 
    public string Name 
    { get; set; } 
} 
  

Unity可以采用编程和配置的方式实现类型的匹配，在真正的系统开发中，后者是首选。为了实现类型匹配配置（UnityTypeElementCollection）到我们定义的UnityTypeMapping列表（IList<UnityTypeMapping>）之间的转化，我定义了下面一个扩展方法（Extension Method）：Copy。

 
public static class Extension 
{ 
    public static IList<UnityTypeMapping> Copy(this UnityTypeElementCollection unityTypeElements) 
    { 
        IList<UnityTypeMapping> mappings = new List<UnityTypeMapping>(); 
        foreach (UnityTypeElement type in unityTypeElements) 
        { 
            mappings.Add(new UnityTypeMapping { Type = type.Type, MapTo = type.MapTo, Name = type.Name }); 
        } 
 
        return mappings; 
    } 
} 
  

下面列出了UnityInstanceProvider的具体定义。属性ContractType与Container分别代表服务契约与用于创建服务实例的UnityContainer对象，字段_registeredTypeMapping表示当前UnityContainer相关的类型匹配集合。出于性能的考虑，为了避免UnityContainer的频繁创建和类型匹配关系的频繁解析，我通过两个静态属性|字段来保存它们（Containers和registeredTypeMappings，Key为Container的名称）。在构造函数中接受两个输入参数：contractType与containerName，分别表示服务契约类型与相应UnityContainer的名称。根据containerName判断相应的UnityContainer是否已经创建，如果是，则直接从上述的两个静态变量中提取相应的UnityContainer和类型匹配列表。否则，重新创建UnityContainer，加载相应的配置信息对其进行配置。需要特别指出的是，在对创建的UnityContainer进行初始化的时候，添加了一个特殊的UnityContainerExtension：ExtendedIntercepiton，该UnityContainerExtension用户实现Unity与PIAB的集成，在《Enterprise Library深入解析与灵活应用（7）：再谈PIAB与Unity之间的集成》中对ExtendedIntercepiton的实现原理具有详细的介绍。

在GetInstance方法中，我们通过UnityContainer根据服务契约（接口）类新进行具体服务实例的创建。在创建之前，我们需要判断服务契约类型与服务类型之间的类型匹配是否已经注册到UnityContainer中，如果没有，则进行注册，并将类型匹配添加到当前类型匹配列表（_registeredTypeMappings）和全局类型匹配列表（registeredTypeMappings）中。

 
public class UnityInstanceProvider : IInstanceProvider 
{ 
    private static object syncHelper = new object(); 
    private static IDictionary<string, IList<UnityTypeMapping>> registeredTypeMappings; 
    public static IDictionary<string, IUnityContainer> Containers 
    { get; private set; } 
 
    private IList<UnityTypeMapping> _registeredTypeMappings; 
    public Type ContractType 
    { get; private set; } 
    public IUnityContainer Container 
    { get; private set; } 
 
    static UnityInstanceProvider() 
    { 
        registeredTypeMappings = new Dictionary<string, IList<UnityTypeMapping>>(); 
        Containers = new Dictionary<string, IUnityContainer>(); 
    } 
 
    public UnityInstanceProvider(Type contractType, string containerName) 
    { 
        if (contractType == null) 
        { 
            throw new ArgumentNullException("contractType"); 
        } 
 
        this.ContractType = contractType; 
 
        string key = containerName ?? string.Empty; 
        if (Containers.ContainsKey(key)) 
        { 
            this.Container = Containers[key]; 
            this._registeredTypeMappings = registeredTypeMappings[key]; 
            return; 
        } 
 
        UnityContainerElement containerElement = this.GetUnitySettings(containerName); 
        IUnityContainer container = new UnityContainer(); 
        if (null != containerElement) 
        { 
            containerElement.Configure(container); 
        } 
        container.AddNewExtension<ExtendedInterception>(); 
        PolicyInjectionSettings section = (PolicyInjectionSettings)ConfigurationSourceFactory.Create().GetSection("policyInjection"); 
        if (section != null) 
        { 
            section.ConfigureContainer(this.Container, ConfigurationSourceFactory.Create()); 
        } 
        lock (syncHelper) 
        { 
            if (!Containers.ContainsKey(key)) 
            { 
                Containers[key] = container; 
                registeredTypeMappings[key] = containerElement.Types.Copy(); 
            } 
        } 
 
        this.Container = container; 
        this._registeredTypeMappings = registeredTypeMappings[key]; 
    } 
 
    #region IInstanceProvider Members 
 
    public object GetInstance(InstanceContext instanceContext, Message message) 
    { 
        string contractServiceTypeMappingName = string.Empty; 
        var contractServiceTypeMappings = from mapping in this._registeredTypeMappings 
                                          where mapping.Type == this.ContractType && 
                                          mapping.MapTo == instanceContext.Host.Description.ServiceType 
                                          select mapping; 
        if (contractServiceTypeMappings.Count() == 0) 
        { 
            contractServiceTypeMappingName = Guid.NewGuid().ToString(); 
            this.Container.RegisterType(this.ContractType, instanceContext.Host.Description.ServiceType, contractServiceTypeMappingName); 
            this._registeredTypeMappings.Add(new UnityTypeMapping { Type = this.ContractType, MapTo = instanceContext.Host.Description.ServiceType, Name = contractServiceTypeMappingName }); 
        } 
        else 
        { 
            contractServiceTypeMappingName = contractServiceTypeMappings.ToArray<UnityTypeMapping>()[0].Name; 
        } 
 
        return this.Container.Resolve(this.ContractType, contractServiceTypeMappingName); 
    } 
 
    private UnityContainerElement GetUnitySettings(string containerName) 
    { 
        UnityConfigurationSection unitySection = ConfigurationManager.GetSection("unity") as UnityConfigurationSection; 
        if (unitySection == null) 
        { 
            return null; 
        } 
 
        if (string.IsNullOrEmpty(containerName)) 
        { 
            return unitySection.Containers.Default; 
        } 
        else 
        { 
            return unitySection.Containers[containerName]; 
        } 
    } 
 
    public object GetInstance(InstanceContext instanceContext) 
    { 
        return this.GetInstance(instanceContext, null); 
    } 
 
    public void ReleaseInstance(InstanceContext instanceContext, object instance) 
    { 
        IDisposable disposable = instance as IDisposable; 
        if (disposable != null) 
        { 
            disposable.Dispose(); 
        } 
    } 
 
    #endregion 
} 
  

三、为UnityInstanceProvider创建Behavor对象

自定义行为（Behavior）是进行WCF扩张最为典型和常用的方式。按照作用域的不同，WCF的行为可以分为以下四类：契约行为（Contract Behavior）、服务行为（Service Contract）、终结点行为（Endpoint Behavior）和操作行为（Operation Behavior）。为了将上面自定义的UnityInstanceProvider应用到WCF服务端的分发系统，定义了如下一个行为类型：UnityIntegrationBehaviorAttribute。我们可以看出，UnityIntegrationBehaviorAttribute同时实现了IServiceBehavior、IContractBehavior和IEndpointBehavior，所以既是一个服务行为，也是一个契约行为，同时还是一个终结点行为。同时UnityIntegrationBehaviorAttribute继承了Attribbute，所以同时可以以Attribute的形式应用到服务契约（作为契约行为）类型和服务（作为服务类型）。你同样可以通过配置的方式以服务行为和终结点行为的方式应用该UnityIntegrationBehaviorAttribute。如果想采用配置的方式，你还需要定义相关的BehaviorExtensionElement，由于篇幅的问题，我就不就对BehaviorExtensionElement的问题作介绍了。

 
   1: using System; 
    using System.Linq; 
    using System.ServiceModel; 
    using System.ServiceModel.Channels; 
    using System.ServiceModel.Description; 
    using System.ServiceModel.Dispatcher; 
    namespace Artech.UnityIntegration 
    { 
        public class UnityIntegrationBehaviorAttribute : Attribute, IServiceBehavior, IContractBehavior,IEndpointBehavior 
        { 
            public string ContainerName 
            { get; set; } 
     
            #region IEndpointBehavior Members 
     
            public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) 
            {             
            } 
     
            public void ApplyClientBehavior(ServiceEndpoint endpoint,ClientRuntime clientRuntime) 
            {            
            } 
     
            public void ApplyDispatchBehavior(ServiceEndpoint endpoint,EndpointDispatcher endpointDispatcher) 
            { 
                endpointDispatcher.DispatchRuntime.InstanceProvider = new UnityInstanceProvider(endpoint.Contract.ContractType, this.ContainerName); 
            } 
     
            public void Validate(ServiceEndpoint endpoint) 
            {             
            } 
     
            #endregion 
     
            #region IContractBehavior Members 
     
            public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) 
            { 
            } 
     
            public void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint,ClientRuntime clientRuntime) 
            { 
            } 
     
            public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint,DispatchRuntime dispatchRuntime) 
            { 
                dispatchRuntime.InstanceProvider = new UnityInstanceProvider(endpoint.Contract.ContractType, this.ContainerName); 
            } 
     
            public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint) 
            { 
            } 
     
            #endregion 
     
            #region IServiceBehavior Members 
     
            public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) 
            { 
            } 
     
            public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase) 
            { 
                foreach (ChannelDispatcher channelDispatcher in serviceHostBase.ChannelDispatchers) 
                { 
                    foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints) 
                    { 
                        endpointDispatcher.DispatchRuntime.InstanceProvider = new UnityInstanceProvider(GetContractType(serviceHostBase, endpointDispatcher), this.ContainerName); 
                    } 
                } 
            } 
     
            private Type GetContractType(ServiceHostBase serviceHostBase, EndpointDispatcher endpointDispatcher) 
            { 
                var endpoint = serviceHostBase.Description.Endpoints.Where(item => item.Contract.Name == endpointDispatcher.ContractName && 
                    item.Contract.Namespace == endpointDispatcher.ContractNamespace).ToArray<ServiceEndpoint>()[0]; 
                return endpoint.Contract.ContractType; 
     
            } 
            public void Validate(ServiceDescription serviceDescription,ServiceHostBase serviceHostBase) 
            { 
            } 
     
            #endregion 
        } 
    } 
  

四、将UnityIntegrationBehavior应用到WCF应用中

为了演示UnityIntegrationBehavior的效果，我们创建了一个简单的WCF实例应用。我们采用《Enterprise Library深入解析与灵活应用（7）：再谈PIAB与Unity之间的集成》中同步时间提供的例子，通过一个服务得到同步的当前时间。下面是服务契约的定义：

 
using System; 
using System.ServiceModel; 
namespace Artech.UnityIntegrationDemo.Contracts 
{ 
    [ServiceContract(Namespace="urn:artech.com")] 
    public interface ISyncTimeProvision 
    { 
        [OperationContract] 
        DateTime GetCurrentTime(); 
    } 
} 
     
  

实现了该服务契约的SyncTimeProvisionService本是并不具体实现不同时间的提供，而是通过另一个组件SyncTimeProvider。你可以将SyncTimeProvider看成是同一个应用的另一个模块，将此例子看成是一个典型的跨模块调用。为了实现真正的模块化，达到模块之间的松耦合，我们借助Unity，采用“属性注入（Propetry Setter Injection）”的方式，通过接口的方式（ISyncTimeProvider）调用另一个模块。为了证实PIAB的效果，我在SyncTimeProvider上面应用了CachingCallHandlerAttribute，如果该CallHandler生效的话，方法返回的结果将会被缓存，在缓存过期之前，你将得到相同的时间。而我们定义的UnityIntegrationBehaviorAttribute以服务行为的方式直接应用到服务类型（SyncTimeProvisionService）上。

 
     
using System; 
using Artech.UnityIntegration; 
using Artech.UnityIntegrationDemo.Contracts; 
using Microsoft.Practices.Unity; 
 
namespace Artech.UnityIntegrationDemo.Services 
{ 
    [UnityIntegrationBehavior(ContainerName="myContainer")] 
    public class SyncTimeProvisionService : ISyncTimeProvision 
    { 
        [Dependency] 
        public ISyncTimeProvider SyncTimeProvider 
        { get; set; } 
 
        #region ISyncTimeProvision Members 
 
        public DateTime GetCurrentTime() 
        { 
            return this.SyncTimeProvider.GetCurrentTime(); 
        } 
 
        #endregion 
    } 
 
    public interface ISyncTimeProvider 
    { 
        DateTime GetCurrentTime(); 
    } 
 
    [CachingCallHandler] 
    public class SyncTimeProvider : ISyncTimeProvider 
    { 
        #region ISyncTimeProvider Members 
 
        public DateTime GetCurrentTime() 
        { 
            return DateTime.Now; 
        } 
 
        #endregion 
    } 
} 
  

在服务寄宿的配置中，提供了WCF服务和Unity的相关设置：

 
     
<?xml version="1.0" encoding="utf-8" ?> 
<configuration> 
  <configSections> 
    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration, Version=1.2.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" /> 
  </configSections> 
    <system.serviceModel> 
        <services> 
            <service name="Artech.UnityIntegrationDemo.Services.SyncTimeProvisionService"> 
                <endpoint address="http://127.0.0.1:3721/synctimeprovisionservice" 
                    binding="ws2007HttpBinding" bindingConfiguration="" contract="Artech.UnityIntegrationDemo.Contracts.ISyncTimeProvision" /> 
            </service> 
        </services> 
    </system.serviceModel> 
  <unity> 
    <typeAliases> 
      <typeAlias alias="ISyncTimeProvider" type="Artech.UnityIntegrationDemo.Services.ISyncTimeProvider, Artech.UnityIntegrationDemo.Services, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" /> 
      <typeAlias alias="SyncTimeProvider" type="Artech.UnityIntegrationDemo.Services.SyncTimeProvider, Artech.UnityIntegrationDemo.Services, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" /> 
    </typeAliases> 
    <containers> 
      <container name="myContainer"> 
        <types> 
          <type type="ISyncTimeProvider" mapTo="SyncTimeProvider" /> 
        </types> 
      </container> 
    </containers> 
  </unity> 
</configuration> 
     
  

当服务成功寄宿，在Console Appliation下，执行下面一段服务端调用程序，你将得到下面的输出。从输出结果中，我们可以清晰地看到，返回的5个返回的时间均是相同的，由此我们可以看出应用才SyncTimeProvider上面的CachingCallHandlerAttribute生效了。进而证明了PIAB和Unity、Unity和WCF的有效集成：

 
     
using System; 
using System.ServiceModel; 
using System.Threading; 
using Artech.UnityIntegrationDemo.Contracts; 
 
namespace Artech.UnityIntegrationDemo.Client 
{ 
    class Program 
    { 
        static void Main(string[] args) 
        { 
            using (ChannelFactory<ISyncTimeProvision> channelFactory = new ChannelFactory<ISyncTimeProvision>("synctimeprovisionservice")) 
            { 
                ISyncTimeProvision proxy = channelFactory.CreateChannel(); 
                using (proxy as IDisposable) 
                { 
                    try 
                    { 
                        for (int i = 0; i < 5; i++) 
                        { 
                            Console.WriteLine("The current time is {0}", proxy.GetCurrentTime()); 
                            Thread.Sleep(1000); 
                        } 
                    } 
                    catch (CommunicationException) 
                    { 
                        (proxy as ICommunicationObject).Abort(); 
                        throw; 
                    } 
                    catch (TimeoutException) 
                    { 
                        (proxy as ICommunicationObject).Abort(); 
                        throw; 
                    } 
                } 
            } 
 
            Console.Read(); 
        } 
    } 
} 
 
     
  