真实世界：使用WCF扩展在方法调用前初始化环境

OperationInvoker 介绍

OperationInvoker 是 WCF 运行时模型中在调用最终用户代码前的最后一个扩展点，OperationInvoker 负责最终调用 Service Operation，并且在 IOperationInvoker 中定义了操作调用的同步和异步模式。

在 WCF 的内部，实现了同步和异步的方法调用类：

• System.ServiceModel.Dispatcher.SyncMethodInvoker
• System.ServiceModel.Dispatcher.AsyncMethodInvoker

上述两个实现是方法调用的默认实现。

IOperationInvoker 接口定义

  // Summary:
  //     Declares methods that take an object and an array of parameters extracted
  //     from a message, invoke a method on that object with those parameters, and
  //     return the method's return value and output parameters.
  public interface IOperationInvoker
  {
    bool IsSynchronous { get; }
    object[] AllocateInputs();
    object Invoke(object instance, object[] inputs, out object[] outputs);
    IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state);
    object InvokeEnd(object instance, out object[] outputs, IAsyncResult result);
  }

问题描述

现在，我们需要在每个服务操作调用前为其单独准备 UnityContainer 环境，目的是保证每个服务操作调用所在的线程使用唯一个 UnityContainer。

假设，设计一个 UnityContainerScope 类来完成此工作。

  public class UnityContainerScope : IDisposable
  {
    public static UnityContainerScope NewScope()
    {
      return new UnityContainerScope();
    }

    public void Dispose()
    {
     
    }
  }

则服务实现中需要为每个操作添加 using (var scope = UnityContainerScope.NewScope()) {} 来完成 Scope 初始化。

  public class CalculatorService : ICalculatorService
  {
    public int Add(int a, int b)
    {
      using (var scope = UnityContainerScope.NewScope())
      {
        return a + b;
      }
    }
  }

解决方案

通过实现 IOperationInvoker 接口，在指定的 Operation 调用前直接调用 UnityContainerScope （仅实现同步接口调用） 。

  public class UnityContainerScopeOperationInvoker : IOperationInvoker
  {
    private IOperationInvoker originalInvoker;

    public UnityContainerScopeOperationInvoker(IOperationInvoker originalInvoker)
    {
      this.originalInvoker = originalInvoker;
    }

    #region IOperationInvoker Members

    public object[] AllocateInputs()
    {
      return this.originalInvoker.AllocateInputs();
    }

    public object Invoke(object instance, object[] inputs, out object[] outputs)
    {
      using (var scope = UnityContainerScope.NewScope())
      {
        return this.originalInvoker.Invoke(instance, inputs, out outputs);
      }
    }

    public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)
    {
      return this.originalInvoker.InvokeBegin(instance, inputs, callback, state);
    }

    public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)
    {
      return this.originalInvoker.InvokeEnd(instance, out outputs, result);
    }

    public bool IsSynchronous
    {
      get { return this.originalInvoker.IsSynchronous; }
    }

    #endregion
  }

通过实现 UnityContainerScopeOperationBehaviorAttribute 来为需要初始化 Scope 的 Operation 进行定制。

  [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false)]
  public sealed class UnityContainerScopeOperationBehaviorAttribute : Attribute, IOperationBehavior
  {
    #region IOperationBehavior Members

    public void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters)
    {
    }

    public void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation)
    {
    }

    public void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation)
    {
      if (dispatchOperation != null)
      {
        dispatchOperation.Invoker = new UnityContainerScopeOperationInvoker(dispatchOperation.Invoker);
      }
    }

    public void Validate(OperationDescription operationDescription)
    {
    }

    #endregion
  }

使用方式：

  [ServiceContract]
  public interface ICalculatorService
  {
    [OperationContract]
    [UnityContainerScopeOperationBehavior]
    int Add(int a, int b);
  }

扩展实现

当然，通常定义 Contracts 的程序集比较纯粹干净，不会有多于的类库引用。而如果 UnityContainerScopeOperationBehaviorAttribute 定义在其他类库中，比如通用类库，则 Contracts 程序集则必须引用该类库。

我们可以通过使用 IEndpointBehavior 来进行行为扩展，而无需在每个 OperationContract 定义上 HardCode 。

  public class UnityContainerScopeEndpointBehavior : IEndpointBehavior
  {
    #region IEndpointBehavior Members

    public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
    {
    }

    public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
    {
    }

    public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
    {
      if (endpoint != null)
      {
        foreach (var operation in endpoint.Contract.Operations)
        {
          bool hasAdded = false;

          foreach (var item in operation.Behaviors)
          {
            if (item.GetType().FullName == typeof(UnityContainerScopeOperationBehaviorAttribute).FullName)
            {
              hasAdded = true;
              break;
            }
          }

          if (!hasAdded)
          {
            operation.Behaviors.Add(new UnityContainerScopeOperationBehaviorAttribute());
          }
        }
      }
    }

    public void Validate(ServiceEndpoint endpoint)
    {
    }

    #endregion
  }

参考资料

• WCF Extensibility – IOperationInvoker