C# .NET Programming Blog

Most WCF services hosted in a live environment if not configured for handling heavy simultaneous requests give a Denial of Service Error, better known as DoS attacks. To prevent these from happening we have to configure the throttling behavior and some attributes of the ServiceHost.

In this article we try to understand and configure each throttling setting of a WCF service and how it affects the execution of the service.

Building a Service

To test this we build a small sample self hosted WCF service. Refer Data Transfer Using Self Hosted WCF Service for more details on how to host an efficient self hosted WCF service for high volumes of data. Configure the service endpoint for a WSHttpBinding as shown in the code.

Show Code

ServiceHost host = new ServiceHost(typeof(ThrottleTester));
host.AddServiceEndpoint(typeof(IThrottleTester), new WSHttpBinding(),
    "http://localhost:9000/ThrottleTest");
host.Open();

The operation performed will be a simple Thread.SpinWait() which will keep the CPU busy. This way we simulate some kind of work. You could perform some actual task here if you prefer.

Show Code

[ServiceContract]
interface IThrottleTester
{
    [OperationContract]
    void Test(int input);
}

class ThrottleTester : IThrottleTester
{
    public ThrottleTester()
    {
        Console.WriteLine("Instantiated");
    }

    public void Test(int input)
    {
        Console.WriteLine(input + ": ON");
        Thread.Sleep(2000);
        Console.WriteLine(input + ": OFF");
    }
}

Building the Client

Now to simulate a client environment that makes concurrent requests to the service we thread requests as shown below. Create a new channel in each thread to consume the service. This will act as multiple clients consuming the service independently.

Show Code

class Program
{
    static ChannelFactory<IThrottleTester> factory;

    static void Main(string[] args)
    {
        factory = new ChannelFactory<IThrottleTester>(new WSHttpBinding(),
            "http://localhost:9000/ThrottleTest");

        while (true)
        {
            for (int i = 0; i < 10; i++)
                new Thread(new ParameterizedThreadStart(Test)).Start(i);

            Thread.Sleep(1000);
        }
    }

    static void Test(object input)
    {
        IThrottleTester tester = factory.CreateChannel();
        tester.Test((int)input);
        ((IClientChannel)tester).Close();
    }
}

Also to simulate continuous requests we repeat the calls after each second. This way we generate 10 calls per second.

Configuring the Service

Now to achieve the main objective of this article, setting up the service for handling concurrent requests.

ConcurrencyMode is the most important setting. We need to set this to ConcurrencyMode.Multiple. This configures the ServiceHost to process multiple requests concurrently. By default it is single, meaning all calls will be processed sequentially.

InstanceContextMode is used to specify whether a new instance or object should be created for handling each call to the service. If you want all the calls to be processed using a single object set this as Single. PerCall and PerSession create a new instance or object for each call or for each session respectively. The number of instances created depends upon the throttling values MaxConcurrentCalls for PerCall and MaxConcurrentSessions for PerSession. So set this according to your need.

MaxConcurrentSessions sets the number of concurrent sessions that will be created for a ServiceHost object. This setting is valid only for bindings that support sessions. Keeping the InstanceContextMode as PerSession we can control the number of sessions that are created concurrently. The default value is 10. For more details on sessions in WCF, refer Using Sessions

MaxConcurrentCalls sets the number of calls that a ServiceHost object will accept concurrently. However if MaxConcurrentCalls is set to some value N and MaxConcurrentSessions is set to a value less than N, and then it might cause a bottleneck. As there are more calls than sessions created it will cause some client requests to get queued up, as new sessions cannot be created. So it is advisable to keep the two values MaxConcurrentCalls and MaxConcurrentSessions equal.

MaxConcurrentInstances is more of a derived value. If InstanceContextMode is PerSession then MaxConcurrentInstances will be same as MaxConcurrentSessions. Similrly if InstanceContextMode is PerCall then MaxConcurrentInstances will be same as MaxConcurrentCalls. However this is valid only in case of ConcurrencyMode is set to Multiple.

Calculating Optimal Throttling

Finally just a little tip in order to help you configure your applications services. We will try to find out what should be the optimal setting for MaxConcurrentCalls and MaxConcurrentSessions for handling multiple concurrent calls.

I have used the word concurrent calls quite a lot in this article. So to start off let me clear out what concurrent calls mean. When a service receives a call when some other call is still open, then they can be termed as concurrent calls.

The best setting depends on 2 factors

1. Number of concurrent calls your service receives.
2. Execution time for each call.

So in our sample, we receive 10 calls per second and execution time for the service method is 2 seconds. While the service is processing the first call we will receive 19 other calls.

The exact safe setting in this case would be 10 x 2 = 20. In a live scenario you might want to add a 20% buffer to this and make it 24.

Show Code

static void Main(string[] args)
{
    ServiceHost host = new ServiceHost(typeof(ThrottleTester));
    host.AddServiceEndpoint(typeof(IThrottleTester), new WSHttpBinding(),
        "http://localhost:9000/ThrottleTest");

    ServiceBehaviorAttribute attribute =
        (ServiceBehaviorAttribute)host.Description
        .Behaviors[typeof(ServiceBehaviorAttribute)];
    attribute.ConcurrencyMode = ConcurrencyMode.Multiple;
    attribute.InstanceContextMode = InstanceContextMode.Single;

    ServiceThrottlingBehavior throttling = new ServiceThrottlingBehavior();
    throttling.MaxConcurrentSessions = 24;
    throttling.MaxConcurrentCalls = 24;

    host.Description.Behaviors.Add(throttling);

    host.Open();

    Console.WriteLine("Service hosted ...");
    Console.ReadKey();
}

Another way of setting concurrency mode is by specifying it during class definition as shown below.

Show Code

[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)]
class ThrottleTester : IThrottleTester
{
	...
}

You can specify throttling using config file by modifying the behavious tag

Show Code

<system.servicemodel>
  <behaviors>
    <serviceBehaviors>
        <behavior name="throttling">
           <serviceThrottling
		maxConcurrentCalls="24"
		maxConcurrentSessions="24"/>
        </behavior>
    </serviceBehaviors>
  </behaviors>
</system.servicemodel>

However this is just a suggestion. You may find many better ways to determine this setting.

Download Sample
ThrottlingTest.zip