3 Ways to Do WCF instance Management (Per call, Per session and Single)

Introduction

Many times we would like to control the way WCF service objects are instantiated on WCF server. You would like to control how long the WCF instances should be residing on the server.

WCF framework has provided 3 ways by which we can control the WCF instance creation. In this article, we will first try to understand those 3 ways of WCF service instance control with simple code samples of how to achieve them. Finally we will compare when to use under what situations.

This is a small Ebook for all my .NET friends which covers topics like WCF, WPF, WWF, Ajax, Core .NET, SQL etc you can download the same from here or else you can catch me on my daily free training @ from here

WCF service object instancing basics

In a normal WCF request and response communication following sequence of actions takes place:-

WCF client makes a request to WCF service object.
WCF service object is instantiated.
WCF service instance serves the request and sends the response to the WCF client.

Following is the pictorial representation of how WCF request and response work.

Following are different ways by which you would like to create WCF instances:-

You would like to create new WCF service instance on every WCF client method call.
Only one WCF service instance should be created for every WCF client session.
Only one global WCF service instance should be created for all WCF clients.

To meet the above scenarios WCF has provided 3 ways by which you can control WCF service instances:-

Per Call
Per session
Single instance

Per Call instance mode

When we configure WCF service as per call, new service instances are created for every method call you make via WCF proxy client. Below image shows the same in a pictorial format:-

WCF client makes first method call (method call 1).
New WCF service instance is created on the server for this method call.
WCF service serves the request and sends response and the WCF instance is destroyed and given to garbage collector for clean up.
Now let's say WCF client makes a second method call, again a new instance is created, request is served and the WCF instance is destroyed.

In other words for every WCF client method call one WCF service instance is created and destroyed once the request is served.

How to implement WCF per call instancing?

In order to specify instancing mode we need to provide 'InstanceContextMode' value in the 'ServiceBehavior' attribute as shown below. This attribute we need to specify on the 'Service' class. In the below code snippet we have specified 'intCounter' as a class level variable as shown below and the class counter is incremented by one when method 'Increment' is called.

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Percall)]
public class Service : IService
{
private int intCounter;
public int Increment()
{
intCounter++
return intCounter;
}
}

At the client we have consumed the WCF client and we have called 'Increment' method twice.

ServiceReference1.ServiceClient obj = new ServiceReference1.ServiceClient();
MessageBox.Show(obj.Increment().ToString());
MessageBox.Show(obj.Increment().ToString());

Even though we have called the 'Increment' method twice we get value '1'. In other words the WCF service instance is created for every method call made to the WCF service instance so the value will always be one.

Per session Instance mode

Many times we would like to maintain state between method calls or for a particular session. For those kind of scenarios we will need to configure the service as per session. In per session only one instance of WCF service object is created for a session interaction. Below figure explains the same in a pictorial format.

Client creates the proxy of WCF service and makes method calls.
One WCF service instance is created which serves the method response.
Client makes one more method call in the same session.
The same WCF service instance serves the method call.
When client finishes his activity the WCF instance is destroyed and served to garbage collector for clean up.

How to implement per session Instancing?

To configure service as per session we need to configure 'ServiceBehavior' attribute with 'PerSession' value in the 'InstanceContextMode' object.

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
public class Service : IService
{
private int intCounter;
public int Increment()
{
intCounter++
return intCounter;
}}

At the client side when we run the below client code. You should see the value as '2' after the final client code is executed. We have called the method twice so the value will be seen as two.

ServiceReference1.ServiceClient obj = new ServiceReference1.ServiceClient();
MessageBox.Show(obj.Increment().ToString());
MessageBox.Show(obj.Increment().ToString());

Single Instance mode

Many times we would like to create one global WCF instance for all WCF clients. To create one single instance of WCF service we need to configure the WCF service as 'Single' instance mode. Below is a simple pictorial notation of how single instance mode will operate:-

WCF client 1 requests a method call on WCF service.
WCF service instance is created and the request is served. WCF service instance is not destroyed the service instance is persisted to server other requests.
Now let's say some other WCF client i.e. client 2 requests a method call.
The same WCF instance which was created by WCF client 1 is used to serve the request of WCF client 2. In other words only one global WCF server service instance is created to serve all client requests.

How to implement Single Instance mode?

In order to create a single instance of WCF service we need to specify the 'InstanceContextMode' as 'Single'.

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
public class Service : IService
{
}

If you call the WCF from different client you will see the counter keep incrementing. The counter has become a global variable.

When should you use per call, per session and single mode?

Per call

You want a stateless services
Your service hold intensive resources like connection object and huge memory objects.
Scalability is a prime requirement. You would like to have scale out architecture.
Your WCF functions are called in a single threaded model.

Per session

You want to maintain states between WCF calls.
You want ok with a Scale up architecture.
Light resource references

Single

You want share global data through your WCF service.
Scalability is not a concern.

References

MSDN link for WCF instances http://msdn.microsoft.com/en-us/library/ms733040.aspx

Do not miss this post which covers end to end about WCF sessions http://codeidol.com/csharp/wcf/Instance-Management/

Great blog by Rick rain on WCF instancing http://blogs.msdn.com/b/rickrain/archive/2009/06/15/wcf-instancing-concurrency-and-throttling-part-1.aspx

Source code

You can download source code for this tutorial from top of this article.