WCF client side instancing and concurrency issues

Hopefully WCF has a reach instancing and concurrency management at service-side via Throttling.

My service client is an ASP.NET application. It consumes more than one WCF service so I create and parametrize WCF client at run-time (no configuration file is used).

Only the end point address is dynamic, and all the services (used by client) have the same method signatures (same contract).

For this reason I have referenced the service through Visual Studio and it has created my service proxy so I just take care of endpoint address at run-time:

class MyWcfClient
{
   void DoSomething(string endpintAddress, int data)
   {
      // Create 'binding' and 'endpoint' ('endpoint' address is dynamic)
      ServiceReference.ServiceClient serviceClient = new ServiceReference.ServiceClient(binding, endpoint);
      // Parametrize 'serviceClient'
 开发者_运维技巧     // Call WCF method (send 'data' to appropriate endpoint)
      serviceClient.CLose();
   }
}

Since the client is an asp.net application, each request runs on it's own worker thread (WCF method calls are very light and fast, so the thread would not block for a long time).

My question is about the instanciation and concurrency at the client-side.

Should MyWcfClient class be Singleton with one serviceClient instance or it be static class and a new serviceClient be created for each call ?

Should I create serviceClient (i.e, an array or list) based on the endpoints (there are 10-100 endpoints) ?

Note that my asp.net threads should not be blocked for a long time (i.e waiting in a queue for sending their related data via WCF)

There is no throttling on client side and it is not needed because you have client code under your control so you have control over number of requests executed. That is the difference to service where without throttling there is no control over number of incomming requests executed elsewhere (out of service control).

So if you want to control number of requests concurrently executed on client you must create object pool - there will be only limited number of MyWcfClient classes available and each class will always create new ServiceClient. Requests will wait in queue for free MyWcfClient instance.

If your only problem is how to create instances of ServiceClient then answer depends on type of binding.

• Sessionful bindings like Net.Tcp, Net.Pipe or WsHttp with reliable session or security context: Create new instance for each communication relation. If your relation is just single call, create new instnace for each call. So you can use static class with static method and create new instance in that method.
• Sessionless bindings like BasicHttp or WebHttp: You can reuse client for multiple calls but you can't close the client between subsequent calls. You can use array of prepared client instances. You will still need to handle some errors here.

Btw. also check asynchronous client calls and how to correctly close the service client.