Posts Tagged ‘WCF’

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

(more…)

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

(more…)

Building the ASP.NET MVC Application

In the last 2 posts we have seen how to develop the Repository and WCF Services for our sample ASP.NET MVC application.This application contains the following Views:

  • Home/Index (Index.aspx) – Displaying the list of Bookmarks with options to Add New,Edit and Delete.
  • Add New (Create.aspx) – Displaying a blank form to enter the URL and Description.
  • Edit (Edit.aspx) – Displaying URL and Description of the selected bookmark.Only Description is editable.

There is a controller BookmarkController for all the above mentioned views.
(more…)

Building the Service

In my last post I have explained step by step how we can implement the Repository pattern with ADO.NET Entity Framework.In this post we will see how to expose that functionality as a WCF service.But prior to that let us briefly touch upon the Service Interface pattern to get our concepts clear.While developing enterprise application most of the times we try to decouple the Business Logic components from the UI components so that the two can evolve and change independently of each other.Along with this the ability to scale out the application across multiple nodes is also another driver.This pattern addresses these forces and provides a solution where we expose our business functionality via a Web Service which can be accessed by multiple clients over the network using varied protocols.

Now we will see step by step how to develop the WCF based Service Interface for our Bookmark Repository.

(more…)

Extensible Objects in WCF

Posted: January 26, 2009 in WCF
Tags: ,

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

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