Instance Pooling in WCF – Part II

In my last post I had started writing about Instance Pooling in WCF and we ended up developing a simple class providing object pooling functionality.In this post we will see what needs to be done step by step to incorporate this instance pool into the WCF framework.

Implementing IInstanceProvider

The class System.Runtime.Dispatcher.DispatchRuntime exposes the property InstanceProvider of type IInstanceProvider.DispatchRuntime uses this instance to acquire and release instances of service objects.IInstanceProvider defines the following methods:

• GetInstance – Returns an service object instance
• ReleaseInstance – Releases a service object instance

Instance Pooling in WCF – Part 1

In my earlier post on WCF behaviors I had given some code snippets on how we can implement pooling in WCF using Behaviors.In this series of posts I am planning to elaborate on the implementation on the same.So to start with the question What is Pooling? needs to be answered.Pooling is a technique where resources are recycled to avoid expensive creation and release of resources.Once the resources are recycled and sent back to pool they lose all their state and identity and are ready to be used again.

To start with first I have defined an interface IResourcePool which defines the contract to acquire and release an object back to the pool.

public interface  IResourcePool
{
    object Acquire();
    void Release(object resource);
}

Extensible Objects in WCF

While exploring the instance context initializer and call context initializer in WCF I came across the extensible objects in WCF.This extensible object pattern is used for extending the runtime behavior of the existing classes or to add custom state information.In this pattern we have an object which wants to provide facility to extend it’s behavior using other custom objects.So this object is an Extensible Object.The custom objects extending the behaviors are Extensions.This is what is modelled using the three interfaces.

• IExtensibleObject <T> where T is the extensible class.This interface enables an object to provide extension point for custom functionality.This interface has only one readonly property:
  • IExtensionCollection<T> Extensions { get; }
• IExtension<T> where T is a type of IExtensibleObject<T>.It enables to extend an object of type IExtensibleObject through aggregation.This interface defines two methods:
  • Attach – Enables an extension object to find out when it has been aggregated.This is called when an extension object is added to the IExtensibleObject<T>.Extensions collection
  • Detach – Enables an extension object to find out when it is no longer aggregated.This is called when an extension object is removed from the IExtensibleObject<T>.Extensions collection
• IExtensionCollection<T> where T is an IExtension object.

In WCF classes following classes provide extension points by implementing the IExtensibleObject interface.

• System.ServiceModel.ServiceHostBase
• System.ServiceModel.InstanceContext
• System.ServiceModel.OperationContext
• System.ServiceModel.IContextChannel

in my next post while discussing about context initializers I will use extensible object in the examples.But this pattern can be used outside WCF as well.This is explained by a nice example in Prajeesh’s blog.

http://blogsprajeesh.blogspot.com/2008/10/using-extensible-object-pattern-to.html

Developing Custom OperationInvoker

In my earlier post I explained the different types of behaviors available in the WCF framework.In this post we will discuss about how to develop a custom operation invoker.Now the obvious question is what is an operation invoker.Operation invoker is the class responsible invoking the service method with a set of parameters and generate the output parameters and return value.The class responsible for this needs to implement the System.ServiceModel.Dispatcher.IOperationInvoker interface.This interface defines the following methods

1. AllocateInputs – Returns an array of parameters required for the method call.
2. Invoke – This method accepts the instance of the service object,array of parameter values ,array of output values as a parameters and returns the value returned by the service method.
3. InvokeBegin – This is the asynchronous version of the Invoke method and initiates the call.
4. InvokeEnd – This is the asynchronous version of the Invoke method and it completes the call.

Operation invoker is attached to the System.ServiceModel.DispatchOperation via the Invoker property.The default invoker provided by WCF framework for synchronous method call is System.ServiceModel.Dispatcher.SyncMethodInvoker.The custom invoker we are going to develop will be added to the DispatchOperation via Invoker property.

This custom invoker will provide a caching functionality.It will check that for a given set of parameters if output and return value exists in cache then it will use the cached values otherwise invoke the method and add results to cache.As a first step we will develop a class implementing IOperationBehavior and it will also wrap the instance of the default operation as shown below:

    public class CacheOperationInvoker:IOperationInvoker
    {
        /// <summary>
        /// This variable keeps a reference to the IOperationInvoker instance of DispatchOperation.
        /// </summary>
        private IOperationInvoker invoker;
        public CacheOperationInvoker(IOperationInvoker invoker)
        {
            this.invoker = invoker;
        }

    …………………
    }

We will now implement the logic to check from cache in the Invoke method as shown below:

public object Invoke(object instance, object[] inputs, out object[] outputs)
{

    //Generate Key method generates the key for cache store by concatenating the input params.
     string key = GenerateKey(inputs);

    //CacheOutput is a custom C# class that encapsulates the output parameter array and return value
     CacheOutput  item = null;
     object retval = null;
     outputs = null;
     if (!string.IsNullOrEmpty(key))
     {

        //Get from Cache
         item = CacheManager.GetItemFromCache(key) as CacheOutput ;
         if (item != null)
         {

            //return from Cache
             retval = item.ReturnValue;
             outputs = item.Outputs;
         }
         else
         {

            //Invoke the method using default invoker instance and set values in cache.
             retval = invoker.Invoke(instance, inputs, out outputs);
             item = new CacheOutput();
             item.Outputs = outputs;
             item.ReturnValue = retval;
             CacheManager.SetItemInCache(key, item);
         }
     }
     return retval;
}

Now we add a operation behavior and add our invoker to DispatchOperation as shown below:

public class CacheOperationBehavior:Attribute,IOperationBehavior
  {

      public void ApplyDispatchBehavior(OperationDescription operationDescription, System.ServiceModel.Dispatcher.DispatchOperation dispatchOperation)
      {
          //Get the instance of the default invoker
          IOperationInvoker invoker = dispatchOperation.Invoker;
          //Override with cache based invoker
          dispatchOperation.Invoker = new CacheOperationInvoker(invoker);
      }

  }

Finally the behavior can be added to the service as shown below:

[ServiceContract]
    public interface ICalculator
    {
        [OperationContract]
        [CacheOperationBehavior]
        int Add(int i, int j);
    }

The entire sample code can be found at:

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=wcfsamples&DownloadId=4496