WCF后续之旅（7）：通过WCF Extension实现和Enterprise Library Unity Container的集成

松耦合、高内聚是我们进行设计的永恒的目标，如何实现这样的目标呢？我们有很多实现的方式和方法，不管这些方式和方法在表现形式上有什么不同，他们的思想都可以表示为：根据稳定性进行关注点的分离或者分解，交互双方依赖于一个稳定的契约，而降低对对方非稳定性因素的依赖。从抽象和稳定性的关系来讲，抽象的程度和稳定程度成正相关关系。由此才有了我们面向抽象编程的说法，所以“只有依赖于不变，才能应万变”。

然后，对于面向对象的思想来讲，我们的功能通过一个个具体的对象来承载。对象是具体的，不是抽象的；创建对象是必然的；对象的创建从某种程度上即使对面向抽象的违背。所以模块之间的耦合度在很大程度上是由于对象创建的方式决定的，而在对象创建过程实现解耦是实现我们“松耦合、高内聚”目标的一个重要途径。对于这一点，我们可以看看我们常用的设计模式中有多少是用于解决如何合理进行对象创建的就可以知道了。Enterprise Library推出的新的Application Block：Unity ApplicationBlock为我们提供了一个很好的、可扩展的框架，帮助我们合理、有效的创建对象，并解决创建对象中的依赖。而通过WCF一个简单的扩展对象，就可以很容易地实现和Unity的集成。

1、Unity Application Block

由于本篇文章的重点仍然是对WCF的扩展，因此我不会花太多的篇幅对Enterprise LibraryUnity作详细的介绍。这是比较官方的定义："The Unity Application Block (Unity) is alightweight, extensible dependency injection container with support forconstructor, property, and method call injection”.Unity实际是建立在ObjectBuilder基础之上，而ObjectBuilder是整个EnterpriseLibrary的基石（实际上还不止于此，MSP&P开发的很多的开源框架都依赖于ObjectBuilder，比如CAB、SCSF等），为我们提供了一个可扩展的、基于策略（strategy based)对象创建方式。借助于ObjectBuilder，Unity可以帮助我们基于Interface或者abstractclass创建对象；可以帮助我们管理对象的生命周期；以及实现依赖注入（DI：DependencyInjection）。下面是3种主要的DI方式：

• Constructor Injection：帮助我们选择我们需要的构造函数来创建对象。
• Property (Setter) Injection：帮助我们在创建的对象上自动设置某些必要的属性值。
• Method Injection：帮助我们在对象上调用我们指定的方法做一些初始化的工作。

如果读者想进一步了解Unity Application Block和Enterprise Library，可以访问微软P&P 的网站。

2、实现基于Unity的IntanceProvider

在本系列的第三部分对Dispachter的介绍，和第四部分对WCF可扩展点的介绍中，我提到了一个重要的对象InstanceProvider， 该对象用于serviceinstance的创建。既然Unity的根本目的是创建对象，我们就可以自定义InstanceProvider，让Unity来帮助创建service instance，很容易地实现了和Unity的集成。

下面是我们的自定义InstanceProvider：UnityInstanceProvider

namespace Artech.WCFExtensions
{
    public class UnityInstanceProvider: IInstanceProvider
    {
        private Type _contractType;
        private string _containerName;

        public UnityInstanceProvider(Type contractType, string containerName)
        {
            if (contractType == null)
            {
                throw new ArgumentNullException("contractType");
            }

            this._containerName = containerName;
            this._contractType = contractType;
        }

        #region IInstanceProvider Members

        public object GetInstance(InstanceContext instanceContext, Message message)
        {
            UnityConfigurationSection unitySection = ConfigurationManager.GetSection("unity") as UnityConfigurationSection;
            if (unitySection == null)
            {
                throw newConfigurationErrorsException(string.Format(CultureInfo.CurrentCulture,Resources.MissUnityConfiguration));
            }

            IUnityContainer container = new UnityContainer();
            UnityContainerElement containerElement;
            if (string.IsNullOrEmpty(this._containerName))
            {
                containerElement = unitySection.Containers.Default;
            }
            else
            {
                containerElement = unitySection.Containers[this._containerName];
            }
            containerElement.Configure(container);
            UnityTypeElement[] unityTypeElements =Array.CreateInstance(typeof(UnityTypeElement),containerElement.Types.Count) as UnityTypeElement[];
            containerElement.Types.CopyTo(unityTypeElements, 0);

            if (unityTypeElements.Where(element => element.Type == this._contractType).Count() == 0)
            {
                container.RegisterType(this._contractType, instanceContext.Host.Description.ServiceType);
            }

            return container.Resolve(this._contractType);
        }

        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
    }
}

 

我们来简单讨论一下上面的逻辑。首先Unity常用的做法就根据Interface或者abstractclass来进行对象的创建，从而实现对抽象的依赖，而Interface或者abstract class和concretetype之间的mapping关系可以通过配置或者代码注册。对于serviceinstace来说，这个Interface就是ServiceContract。而Unity通过一个叫做UnityContainer对象创建具体的对象和进行生命周期的管理，Container是一个囊括了所有对象创建和生命周期管理所需资源的容器。这些资源包括：Interface或者abstract class和concrete type之间的mapping关系；DependencyInjection的定义；Extensions等等。UnityContainer之间可以嵌套从而形成一个树状结构，我们可以通过一个ID来定位我们需要的container。所以我们定义了两个field:_contractType和_containerName。

private Type _contractType;
private string _containerName;

 

GetInstance方式提供了service instance创建的实现。具体是这样做的：

UnityConfigurationSection unitySection = ConfigurationManager.GetSection("unity") as UnityConfigurationSection;
if (unitySection == null)
{
    throw new ConfigurationErrorsException(string.Format(CultureInfo.CurrentCulture,   Resources.MissUnityConfiguration));
}
在配置文件中找到unity的配置，如何没有找到抛出ConfigurationErrorsException异常。

IUnityContainer container = new UnityContainer();
UnityContainerElement containerElement;
if (string.IsNullOrEmpty(this._containerName))
{
      containerElement = unitySection.Containers.Default;
}
else
{
      containerElement = unitySection.Containers[this._containerName];
}
containerElement.Configure(container);

然后创建UnityContainer对象，然后通过配置的信息对我们创建的UnityContainer进行配置。如何我们没有制定container name，使用默认的配置节，否则使用container name制定的配置节。

UnityTypeElement[] unityTypeElements =Array.CreateInstance(typeof(UnityTypeElement),containerElement.Types.Count) as UnityTypeElement[];
containerElement.Types.CopyTo(unityTypeElements, 0);

if (unityTypeElements.Where(element => element.Type == this._contractType).Count() == 0)
{
     container.RegisterType(this._contractType, instanceContext.Host.Description.ServiceType);
}

因为很有可能在unity的配置中，并没有ServiceContracttype对应的配置项，在这种情况下，我将自动注册ServiceContract和ServiceType的匹配关系，ServiceType通过instanceContext.Host.Description.ServiceType获得。

最后通过UnityContainer的Resolve创建service instance。

return container.Resolve(this._contractType);

3、创建UnityInstanceProvider对应的Behavior

InstanceProvider可以通过ContractBehavior来指定，也可以通过EndpointBehavior来指定，我们首先创建ContractBehavior：UnityBehaviorAttribute。由于ContractBehavior通过CustomAttribute的形式指定，所以UnityBehaviorAttribute是一个attribute.

namespace Artech.WCFExtensions
{
    public class UnityBehaviorAttribute:Attribute, IContractBehavior
    {
        public string ContainerName
        { get; set; }

        #region IContractBehavior Members

        public voidAddBindingParameters(ContractDescription contractDescription,ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
        {}

        public voidApplyClientBehavior(ContractDescription contractDescription,ServiceEndpoint endpoint, ClientRuntime clientRuntime)
        {}

        public voidApplyDispatchBehavior(ContractDescription contractDescription,ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)
        {
           dispatchRuntime.InstanceProvider = new UnityInstanceProvider(contractDescription.ContractType, this.ContainerName);
        }

        public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint)
        {}

        #endregion
    }
}

需要做的仅仅是在ApplyDispatchBehavior中，将当前的DispatchRuntime的InstanceProvider 指定成我们的UnityInstanceProvider。

我们再定义一下EndpointBehavior：UnityBehavior。

namespace Artech.WCFExtensions
{
   public class UnityBehavior: IEndpointBehavior
    {
       private string _containerName;

       public UnityBehavior(string containerName)
       {
        this._containerName = containerName;
       }

        #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
    }
}

在ApplyDispatchBehavior，通过endpointDispatcher.DispatchRuntime获得当前的DispatchRuntime对象，并将InstanceProvider我们的UnityInstanceProvider。

最后为了UnityBehavior定义BehaviorExtensionElement：

namespace Artech.WCFExtensions
{
    public class UnityBehaviorElement: BehaviorExtensionElement
    {
        [ConfigurationProperty("containerName", IsRequired = false, DefaultValue = "")]
        public string ContainerName
        {
            get
            {
                return this["containerName"] as string;
            }
            set
            {
                this["containerName"] = value;
            }
        }

        public override Type BehaviorType
        {
            get
            {
                return typeof(UnityBehavior);
            }
        }

        protected override object CreateBehavior()
        {
            return new UnityBehavior(this.ContainerName);
        }
    }
}

添加一个ContainerName的配置项，在配置文件中指定。

4、应用我们的UnityInstanceProvider

我们现在将我们上面所做的所有工作应用到具体的WCF调用场景中。为此我们创建了一个MessageService的例子（根据Message的Key的Culture返回具体的message的内容），这个例子在本系列第五部分中介绍通过WCFextension实现Localization中介绍过。

这是我们经典的四层结构：

I、Artech.Messages.Contract：

namespace Artech.Messages.Contract
{
    [ServiceContract]
   [UnityBehavior(ContainerName ="wcfservice")]
    public interface IMessage
    {
        [OperationContract]
        string GetMessage(string key);
    }
}

在IMessage上应用了我们的ContractBehavor：UnityBehavior，同时指定container name为：wcfservice。

II、Artech.Messages.Service

namespace Artech.Messages.Service
{
    public class MessageService:IMessage
    {
       [Dependency]
        public IMessageManager MessageManager
        { get; set; }

       [InjectionMethod]
        public void Initialize()
        {
            Thread.CurrentThread.CurrentCulture = new CultureInfo("zh-CN");
            Thread.CurrentThread.CurrentUICulture = new CultureInfo("zh-CN");
        }

        #region IMessage Members

        public string GetMessage(string key)
        {
            return this.MessageManager.GetMessage(key, Thread.CurrentThread.CurrentUICulture);
        }

        #endregion
    }

    public interface IMessageManager
    {
        string GetMessage(string key, CultureInfo culture, params object[] parameters);
    }

    public class MessageManager : IMessageManager
    {
        public ResourceManager ResourceManager
        { get; set; }

        public MessageManager()
        {
            this.ResourceManager =new ResourceManager("Artech.Messages.Service.Properties.Resources",typeof(Resources).Assembly);
        }

        #region IMessageManager Members

        public string GetMessage(string key, CultureInfo culture, params object[] parameters)
        {
            string message = ResourceManager.GetString(key, culture);
            return string.Format(culture, message, parameters);
        }

        #endregion
    }
}

对于MessageService，需要着重介绍一下。因为使用到了一些Unity的Attribute。首先是MessageManager属性，它是一个Interface，上面标注了[Dependency]，表明这是一个依赖属性。仔细看代码，此MessageManager并没有进行赋值的地方，而且此属性直接用在了GetMessage（）方法上。实际上，对MessageManager进行初始化就是Unity container为我们实现的，在创建MessageService对象后，Unitycontainer会来本container的范围了找到IMessageManager 找到与之复配的concrete type。

[Dependency]
public IMessageManager MessageManager
{ get; set; }

对于我们创建出来的MessageService的对象，我们希望能够自动调用一些初始化的方法来进行一些初始化的工作，我们可以通过InjectionMethodAttribute来实现。在Initialize，我希望指定当前的culture为简体中文（我当前机器默认为en-US）

[InjectionMethod]
public void Initialize()
{
    Thread.CurrentThread.CurrentCulture = new CultureInfo("zh-CN");
    Thread.CurrentThread.CurrentUICulture = new CultureInfo("zh-CN");
}

而MessageManager 实现了IMessageManager ，提供了GetMessage的真正实现。Message存储在Resource温家中：

Default:

zh-CN:

III、Artech.Messages.Hosting

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="unity"type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration, Version=1.1.0.0,Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
  </configSections>

  <system.serviceModel>
       <services>
      <service name="Artech.Messages.Service.MessageService">
        <endpoint behaviorConfiguration="" binding="basicHttpBinding"
            contract="Artech.Messages.Contract.IMessage" />
        <host>
          <baseAddresses>
            <add baseAddress="http://127.0.0.1/messageservice" />
          </baseAddresses>
        </host>
      </service>
    </services>
  </system.serviceModel>

  <unity>
    <containers>
      <container name="wcfservice">
        <types>
              <typetype="Artech.Messages.Service.IMessageManager,Artech.Messages.Service"mapTo="Artech.Messages.Service.MessageManager,Artech.Messages.Service"/>
        </types>
      </container>
    </containers>
  </unity>
</configuration>

在unity配置节中，定义了名为wcfservice的container，该名称就是在ServiceContract在UnitBehavior中指定的参数。在该container中定了了IMessageManager和具体的type（MessageManager）之间的匹配。这解决了MessageService中MessageManager属性的实例化的问题。

IV、Artech.Messages.Client

namespace Artech.Messages.Client
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ChannelFactory<IMessage> channelFactory = new ChannelFactory<IMessage>("messageservice"))
            {
                IMessage messageProxy = channelFactory.CreateChannel();
                Console.WriteLine(messageProxy.GetMessage("HelloWorld"));               
            }

            Console.Read();
        }
    }
}

messageservice是配置的endpoint的名称。config文件就不列出来了。最后我们运行程序看最终的结果：

V、使用EndpointBehavior

上面我们是通过ContractBeahvior。现在我们将ServiceContract的UnityBehaviorAttribute去掉，在config中运用我们的EndpointBehavior：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="unity"type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration, Version=1.1.0.0,Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
  </configSections>
  <system.serviceModel>
    <behaviors>
      <endpointBehaviors>
       <behavior name="UnityBehavior">
          <UnityBehaviorExtension containerName="wcfservice" />
        </behavior>
      </endpointBehaviors>
    </behaviors>
    <extensions>
      <behaviorExtensions>
       <addname="UnityBehaviorExtension"type="Artech.WCFExtensions.UnityBehaviorElement, Artech.WCFExtensions,Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      </behaviorExtensions>
    </extensions>
    <services>
      <service name="Artech.Messages.Service.MessageService">
        <endpoint behaviorConfiguration="UnityBehavior" binding="basicHttpBinding"
            contract="Artech.Messages.Contract.IMessage" />
        <host>
          <baseAddresses>
            <add baseAddress="http://127.0.0.1/messageservice" />
          </baseAddresses>
        </host>
      </service>
    </services>
  </system.serviceModel>
  <unity>
    <containers>
      <container name="wcfservice">
        <types>
          <typetype="Artech.Messages.Service.IMessageManager,Artech.Messages.Service"mapTo="Artech.Messages.Service.MessageManager,Artech.Messages.Service"/>
        </types>
      </container>
    </containers>
  </unity>
</configuration>

我们一样可以得到上面的结果。