Question

I am currently looking at some code which basically reads data line-by-line from a file and calls an appropriate method on a WCF client for each line. My problem with the code is that a new client is created for each operation ie:

function CallSomeOp(line)
 {
   using (var client = new Client()
   {
       client.SomeOp(line);
   }
 }

This seems to make the client close the connection and reopen a new one for each line in the file which seems like a big overhead. What I would like to do is move the creation of the client outside the function and into initialization, so that multiple operations are called on one client, ie:

 using (var client = new Client())
 {
     for(var line in lines)
     {
        CallSomeOp(line, client);
     }
 }

But I’m not sure if this is OK or not. Is there some problem with calling multiple operations on a client, ie will I eventually run out of memory or something?

Answer 1

An operation is typically stateless, so that’s expected behaviour. You can change the InstanceContextMode though. This determines if a new instance is created with each call or that there is a single instance. The question is, should you? Like I said, a single call is typically stateless. Having just a single instance doesn’t scale very well either. I’d suggest to keep InstanceContextMode to be PerCall, that way, for every call the webserver creates a single instance, I wouldn’t worry too much about overhead. If overhead really does become a problem, maybe a service isn’t what you need.

Then there’s the ConcurrencyMode which allows you to specify multiple threads to be created.

As far as the client is concerned, you don’t need to re-create it everytime you want to call an operation. Alternatively, you could also look at the ChannelFactory if both client and server have knowledge of the contract. This answer provides some detail.