using (wcfclient) { } kaboom!

I've been doing a lot of WCF development lately (love it) and ran into a bit of a stumbling block. The proxy client generated by Visual Studio 2008 Beta 2 doesn't handle fault conditions and dispose well. I have to admit, I haven't used WCF in Visual Studio 2005. If you're impatient here's the project (Visual Studio 2008 Beta 2 project): wcfwrapper.zip The situation unfolds:

The Problem - Dispose Isn't Safe!

1. Create a WCF service.

   [ServiceContract]public interface IGoodBadService{   [OperationContract]   void Good();   [OperationContract]   void Bad();}
   

2. Add a service reference to your service in another project.

3. Create a service client and use it, with a "using" block (it is IDisposable, afterall).

   try{   using (GoodBadServiceClient c =       new GoodBadServiceClient())   {       c.Bad();   }}catch (Exception ex){   Console.WriteLine(ex.Message);}
   

4. A call to your service, for whatever reason, throws an exception.

   public class GoodBadService   : IGoodBadService{   public void Good()   {       throw new Exception("GOOD!");   }   public void Bad()   {       throw new Exception("BAD!");   }}
   

5. You get a cryptic System.ServiceModel.CommunicationObjectFaultedException instead of the real exception when using calls Dispose() on your proxy client. It reads: The communication object, System.ServiceModel.Channels.ServiceChannel, cannot be used for communication because it is in the Faulted state.

The Solution - A Simple Generic Wrapper

public class ServiceProxy<TClient>   : IDisposable   where TClient : ICommunicationObject{   public ServiceProxy(TClient client)   {       Client = client;   }   public TClient Client { get; private set; }   public void Dispose()   {       if (null != Client &&           Client.State != CommunicationState.Closed &&           Client.State != CommunicationState.Faulted)       {           Client.Close();       }   }}

Using the wrapper is pretty straightforward, but a tad more cryptic than just using the client directly. Some of this can be avoided with a generic factory.

So, here's how you use it:

try{   using (ServiceProxy<GoodBadServiceClient> c       = new ServiceProxy<GoodBadServiceClient>(           new GoodBadServiceClient()))   {       c.Client.Good();   }}catch (Exception ex){   Console.WriteLine(ex.Message);}

Run the project and check out the results. The wrapper gives you the actual exception, whereas "using" the client directly causes the CommunicationObjectFaultedException. Here's the project (Visual Studio 2008 Beta 2 project): wcfwrapper.zip