Question

I’d like to override the Dispose method of generated proxy (ClientBase) because of the fact that disposing of a proxy calls Close and can throw an exception when the channel is faulted.

The only way I came up was to create a partial class to my generated proxy, make it inherit from IDisposable:

 public partial class MyServiceProxy : IDisposable
    {
        #region IDisposable Members

        public void Dispose()
        {
            if (State != System.ServiceModel.CommunicationState.Faulted)
                Close();
            else
                Abort();
        }

        #endregion
    }

I did some test and my Dispose method is indeed called.

Do you see any issue with this strategy?

Also, I don’t like the fact that I’ll have to create this partial class for every generated proxy.

It be nice if I was able to make my proxy inherit from a base class…

Answer 1

There’s no issue with it. Customizing designer-generated code in this fashion is exactly the feature that partial classes are intended to provide, and this is one of the recommended ways of dealing with the broken IDisposable implementation on ClientBase.

As for having to re-implement this code for every WCF client – unfortunately, yes, you will, if you want to use the IDisposable pattern with these. You could extract the if/else block into a utility method but you would still have to create a partial class for each one and override Dispose.

Seeing as how the above is rather tedious to do, many people choose to use the Service Proxy Helper instead, since it doesn’t require writing any new code.

I use a slightly modified version, myself:

public static class Service<TProxy>
    where TProxy : ICommunicationObject, IDisposable, new()
{
    public static void Using(Action<TProxy> action)
    {
        TProxy proxy = new TProxy();
        bool success = false;
        try
        {
            action(proxy);
            proxy.Close();
            success = true;
        }
        finally
        {
            if (!success)
            {
                proxy.Abort();
            }
        }
    }
}

Which allows writing this kind of code:

Service<MyServiceClient>.Using(svc => svc.PerformOperation());

Or:

Service<MyServiceClient>.Using(svc =>
{
    var result = svc.PerformOperation();
    ProcessResult(result);
});

Note: WCF proxies are expensive to create, so you generally want to try to keep them alive as long as possible instead of creating and disposing them every few seconds (or more). This is intended for clients that are infrequently-used.