Object instances in static classes

Question

I am developing a web application with multiple WCF service references. Currently, each time we need to make a call to a service we do the following(as an example):

Service.ServiceClient ServiceClient = new Service.ServiceClient();
ServiceClient.SomeMethod();

Would it be better to have a static class with static references to each Service and call that class instead, thereby avoiding creating a new instance of the ServiceClient object each time we want to call it?

For example:

public static class Services
{
    private static Service.ServiceClient _ServiceClient = new Service.ServiceClient();
    public Service.ServiceClient ServiceClient
    {
        get
        {
            return _ServiceClient;
        }
    }
}

And, if doing it this way, would the line

private static Service.ServiceClient _ServiceClient = new Service.ServiceClient();

cause a new object to be created each time we try to call that object, or will it be the same instance of that object every time we make a call to it?

Answer 1

You can have a class which will have all the functions exposed by your data contract. All these methods will be static. Now inside these function you can do as follows

public class ServiceManager{
    public static CalculatedData SomeMethod()
    {
         var client = GetClient();
         try
         {
             return client.SomeMethod();
         }
         catch(Exception ex)
         {
             //Handle Error
         }
         finally
         {
             if(client.State == System.ServiceModel.CommunicationState.Opened)
                client.Close();
         } 

    }
    private static SomeClient GetClient()
    {
         return new ServiceClient();
    }
} 

Consumer will consume it like

var calculatedData = ServiceManager.SomeMethod();

Answer 2

You could use a helper like the following:

private delegate void ServiceAction(Service.ServiceClient client);

private static void PerformServiceAction(ServiceAction serviceAction)
{
  using (var client = new Service.ServiceClient())
  {
    serviceAction(client);
  }
}

which can then be invoked the following way:

Helper.PerformServiceAction(client => client.SomeMethod());

It still creates a proxy for every call or sequence of calls but at least your calling code is lighter.

(Keep in mind that using 'using' with a wcf client proxy is not a good idea because dispose might throw an exception so it's better to catch exceptions and to close the proxy gracefully manually).

Answer 3

It will only be created once, you will have no control however over when it will be created. The usual way to handle this is either create a seperate static method (init for example) where you create the instance or create it when first called. You should check the singleton design pattern for this.

Answer 4

if you want to do so create

Singleton Service

The singleton service is the ultimate sharable service. When a service is configured as a singleton, all clients independently get connected to the same single well-known instance, regardless of which endpoint of the service they connect to. The singleton service lives forever and is only disposed of once the host shuts down. The singleton is created exactly once, when the host is created.

You configure a singleton service by setting the InstanceContextMode property to InstanceContextMode.Single:

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
class MySingleton : ...
{...}