WCF Server (net-tcp) against backand running non-thread-safe unmanaged code - multithreading

Question

I've been tasked with writing a WCF service host (server) for an existing (session-full) service -- not hard so far. The service is an ADO Proxy server that proxies ADO connections to various back end databases. This works well in most cases, but one of the ADO .NET data providers I need to support is implemented as a driver connecting to an unmanaged code (C) API that is not thread-safe.
The preferred solutions, make the code thread-safe or implement a thread-safe, managed driver are off the table right now. It's been suggested that I could spin multiple processes as a sort of back end or second level proxy, but this struck me as a nightmare to implement when I first heard it, and even more so as I did a trial implementation.
My question is, is there another solution I am missing here? I've played around so far with ConncurrencyMode.Single And UseSynchronization = true, but the real heart of the matter is being both sessionfull and having a non-thread-safe back end. So far no luck. Am I stuck with proxying the connection to multiple processes, or can someone else suggest a more elegant solution?
Thanks!

Answer 1

What I would do (actually I have been in this very situation myself) is to spin up a dedicated thread that will service requests dispatched to the unmanaged API. The thread will sit there waiting for a request message. The request message will instruct the thread to do something with the API. Once the thread is finished processing the request it construct a response message. The response message will contain the returned data. The pattern is super easy if you use BlockingCollection to queue the request and response messages.
public class SingleThreadedApiAbstraction
{
private BlockingCollection<Request> requests = new BlockingCollection<Request>();
private BlockingCollection<Response> responses = new BlockingCollection<Response>();
public SingleThreadedApiAbstraction()
{
var thread = new Thread(Run);
thread.IsBackground = true;
thread.Start();
}
public /* Return Type */ SomeApiMethod(/* Parameters */)
{
var request = new Request(/* Parameters */);
requests.Add(request); // Submit the request.
var response = responses.Take(); // Wait for the response.
return response.ReturnValue;
}
private void Run()
{
while (true)
{
var request = requests.Take(); // Wait for a request.
// Forward the request parameters to the API.
// Then construct a response object with the return value.
var response = new Response(/* Returned Data */);
responses.Add(response); // Publish the response.
}
}
}
The idea is that the API is only ever accessed via this dedicated thread. It does not matter how or who is calling SomeApiMethod. It is important to note that Take blocks if the queue is empty. The Take method is where the magic happens.