gistfile1.cs

public class WcfService<T> : IDisposable where T : class
{
    private readonly object _lockObject = new object();

    private bool _disposed;
    private ChannelFactory<T> _factory;
    private T _channel;

    internal WcfService()
    {
        _disposed = false;
    }

    internal virtual T Channel
    {
        get
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("Resource WcfService<" + typeof(T) + "> has been disposed");
            }

            lock (_lockObject)
            {
                if (_factory == null)
                {
                    _factory = new ChannelFactory<T>("*"); // First qualifying endpoint from the config file
                    _channel = _factory.CreateChannel();
                }
            }

            return _channel;
        }
    }

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

    internal void Dispose(bool disposing)
    {
        if (_disposed)
        {
            return;
        }

        if (!disposing)
        {
            return;
        }

        lock (_lockObject)
        {
            if (_channel != null)
            {
                try
                {
                    ((IClientChannel)_channel).Close();
                }
                catch (Exception)
                {
                    ((IClientChannel)_channel).Abort();
                }
            }

            if (_factory != null)
            {
                try
                {
                    _factory.Close();
                }
                catch (Exception)
                {
                    _factory.Abort();
                }
            }

            _channel = null;
            _factory = null;
            _disposed = true;
        }
    }
}