WCF suspended call

Question

I have a WCF service that implements long-polling. However, I see no way to have each service call spawn a new thread upon being called.

As it stands, the long-polled contract is waiting for an event to occur and is blocking any other contracts from being called.

What is the recommended way to have one contract run asynchronously from another contract in WCF?

I thought of keeping a static thread pool but I'm not quite sure if that solution scales.

Thanks!

Answer 1

In the context of your question, I assume long-polling is some kind of an operation which is periodically issuing an HTTP request to a 3rd party resource, until a desired response has been returned, or until timed out.

To implement it efficiently, you can use .NET 4.5, TAP pattern and async/await.

Example (untested):

// contract

[ServiceContract]
public interface IService
{
    //task-based asynchronous pattern
    [OperationContract]
    Task<bool> DoLongPollingAsync(string url, int delay, int timeout);
}

// implementation

public class Service : IService
{
    public async Task<bool> DoLongPollingAsync(
        string url, int delay, int timeout)
    {
        // handle timeout via CancellationTokenSource
        using (var cts = new CancellationTokenSource(timeout))
        using (var httpClient = new System.Net.Http.HttpClient())
        using (cts.Token.Register(() => httpClient.CancelPendingRequests()))
        {
            try
            {
                while (true)
                {
                    // do the polling iteration
                    var data = await httpClient.GetStringAsync(url).ConfigureAwait(false);
                    if (data == "END POLLING") // should we end polling?
                        return true;

                    // pause before the next polling iteration
                    await Task.Delay(delay, cts.Token);
                }
            }
            catch (OperationCanceledException)
            {
                // is cancelled due to timeout?
                if (!cts.IsCancellationRequested)
                    throw;
            }
            // timed out
            throw new TimeoutException();
        }
    }
}

This scales well, because most of the time the DoLongPolling is in the pending state, asynchronously awaiting the result of HttpClient.GetStringAsync or Task.Delay calls. Which means it doesn't block a thread from ThreadPool, so the WCF service can serve more DoLongPolling requests concurrently. Check "There Is No Thread" by Stephen Cleary for more details on how this works behind the scene.

On the client side, you can call your WCF service asynchronously, too. Tick "Allow generation of asynchronous operations" when you create the WCF service proxy and select "Generate task-based operations".

If you need to target .NET 4.0, you can find some alternative options in "Asynchronous Operations in WCF" by Jaliya Udagedara.