WCF wrapper implementing dispose-finalize pattern

Question

I tried to implement the dispose-finalize pattern on this WCF wrapper.

Do you have any comments about this? Something I missed?

namespace System.ServiceModel
{
    public class WCFClientWrapper<TProxy> : IDisposable where TProxy : class
    {
        private string _endpointAddress;
        public TProxy Service { get; private set; }

        public WCFClientWrapper(string endpointAddress)
        {
            _endpointAddress = endpointAddress;

            var factory = new ChannelFactory<TProxy>(new NetTcpBinding(), new EndpointAddress(endpointAddress));
            Service = factory.CreateChannel();

            (Service as IClientChannel).Faulted += WCFClientWrapper_Faulted;
        }

        private TProxy CreateChannel(string endpointAddress)
        {
            var factory = new ChannelFactory<TProxy>(new NetTcpBinding(), new EndpointAddress(endpointAddress));
            return factory.CreateChannel();
        }

        void WCFClientWrapper_Faulted(object sender, EventArgs e)
        {
            DisposeService();
            Service = CreateChannel(_endpointAddress);
        }

        public void Dispose(bool disposing)
        {
            if (disposing)
            {
                // get rid of managed resources
            }   

            DisposeService();
            GC.SuppressFinalize(this);
        }

        private void DisposeService()
        {
            IClientChannel serviceChannel = Service as IClientChannel;
            if (serviceChannel == null)
                return;

            bool success = false;
            try
            {
                (Service as IClientChannel).Faulted -= WCFClientWrapper_Faulted;

                if (serviceChannel.State != CommunicationState.Faulted)
                {
                    serviceChannel.Close();
                    success = true;
                }
            }
            finally
            {
                if (!success)
                {
                    serviceChannel.Abort();
                }
            }
        }

        public void Dispose()
        {
            Dispose(true);
        }

        ~WCFClientWrapper()
        {
            Dispose(false);
        }
    }
}

Answer 1

Given that much of the code seems to rely on Service being an IClientChannel, and the name of the class implies as such, it may be worth simply adding IClientChannel to your type constraints and remove all the type conversion code.

Building upon that thought, I notice that IClientChannel extends IChannel, and everything you use seems to be present on IChannel. You may consider using that interface instead, and renaming your class to reflect that it is not limited to IClientChannel.

Answer 2

I saw some duplication of code, which could easily be centralized and eliminated. I also renamed a few pieces as per Microsoft Framework Design Guidelines. Finally, you may also want to look at this bit of code which seems somewhat similar and caches the service proxy rather than recreating it for each call.

namespace System.ServiceModel
{
    public class WcfClientWrapper<TProxy> : IDisposable where TProxy : class
    {
        private string endpointAddress;

        private TProxy service;

        public WcfClientWrapper(string endpointAddress)
        {
            this.service = this.CreateChannel(endpointAddress);

            var serviceChannel = this.service as IClientChannel;

            if (serviceChannel == null)
            {
                return;
            }

            serviceChannel.Faulted += this.ClientChannelFaulted;
        }

        ~WcfClientWrapper()
        {
            this.Dispose(false);
        }

        public TProxy Service
        {
            get
            {
                return this.service;
            }
        }

        public void Dispose()
        {
            this.Dispose(true);
        }

        public void Dispose(bool disposing)
        {
            if (disposing)
            {
                // get rid of managed resources
            }

            this.DisposeService();
            GC.SuppressFinalize(this);
        }

        private TProxy CreateChannel(string newEndpointAddress)
        {
            this.endpointAddress = newEndpointAddress;

            var factory = new ChannelFactory<TProxy>(new NetTcpBinding(), new EndpointAddress(newEndpointAddress));

            return factory.CreateChannel();
        }

        private void ClientChannelFaulted(object sender, EventArgs e)
        {
            this.DisposeService();
            this.service = this.CreateChannel(this.endpointAddress);
        }

        private void DisposeService()
        {
            var serviceChannel = this.service as IClientChannel;

            if (serviceChannel == null)
            {
                return;
            }

            var success = false;

            try
            {
                serviceChannel.Faulted -= this.ClientChannelFaulted;
                if (serviceChannel.State != CommunicationState.Faulted)
                {
                    serviceChannel.Close();
                    success = true;
                }
            }
            finally
            {
                if (!success)
                {
                    serviceChannel.Abort();
                }
            }
        }
    }
}