WCF clients need to be cleaned up properly, but as they're usually auto-generated they don't implement IDisposable. I've been doing a fair bit of WCF work recently, so I wrote a generic WCF client wrapper which effectively gives me a disposable service client.

The ServiceClientWrapper is constructed using a WebServiceConfig instance, which contains a Binding, an EndPointAddress, and whether the client should ignore SSL certificate errors - pretty useful during testing! The Binding can be created based on configuration data or entirely programmatically - that's not the client's concern.

Here's the service client code:

using System;
using System.Net;
using System.Net.Security;
using System.ServiceModel;

public class ServiceClientWrapper<TService, TChannel> : IDisposable
    where TService : ClientBase<TChannel>
    where TChannel : class
{
    private readonly WebServiceConfig _config;

    private TService _serviceClient;

    public ServiceClientWrapper(WebServiceConfig config)
    {
        this._config = config;
    }

    public TService CreateServiceClient()
    {
        this.DisposeExistingServiceClientIfRequired();

        if (this._config.IgnoreSslErrors)
        {
            ServicePointManager.ServerCertificateValidationCallback =
                (obj, certificate, chain, errors) => true;
        }
        else
        {
            ServicePointManager.ServerCertificateValidationCallback =
                (obj, certificate, chain, errors) => errors == SslPolicyErrors.None;
        }

        this._serviceClient = (TService)Activator.CreateInstance(
            typeof(TService),
            this._config.Binding,
            this._config.Endpoint);

        if (this._config.ClientCertificate != null)
        {
            this._serviceClient.ClientCredentials.ClientCertificate.Certificate =
                this._config.ClientCertificate;
        }

        return this._serviceClient;
    }

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

    private void DisposeExistingServiceClientIfRequired()
    {
        if (this._serviceClient != null)
        {
            try
            {
                if (this._serviceClient.State == CommunicationState.Faulted)
                {
                    this._serviceClient.Abort();
                }
                else
                {
                    this._serviceClient.Close();
                }
            }
            catch
            {
                this._serviceClient.Abort();
            }

            this._serviceClient = null;
        }
    }
}

A client for a particular service can then be created something like this:

public class ManagementServiceClientWrapper :
    ServiceClientWrapper<ManagementServiceClient, IManagementService>
{
    public ManagementServiceClientWrapper(WebServiceConfig config)
        : base(config)
    {
    }
}

...where ManagementServiceClient is the auto-generated client class, and the IManagementService is the auto-generated WCF channel class - and used like this:

using(var serviceClientWrapper = new ManagementServiceClientWrapper(config))
{
    serviceClientWrapper.CreateServiceClient().CallService();
}

The underlying WCF client created by the CreateServiceClient() will be disposed after the using, and hey presto - a disposable WCF service client.