Как правильно удалить прокси-сервер WCF?

Проблема, насколько мне удалось понять, заключается в том, что вызов Dispose отключает дескриптор, но на самом деле не закрывает канал, который затем удерживает ресурсы, а затем в конечном итоге истекает время ожидания.

Вот почему ваша служба перестала отвечать через некоторое время во время нагрузочного тестирования: потому что первоначальные вызовы удерживали ресурсы дольше, чем вы думали, а последующие вызовы не могли использовать эти ресурсы.

Я пришел к следующему решению. Предпосылка решения состоит в том, что вызова Dispose должно быть достаточно, чтобы избавиться от дескриптора, а также закрыть канал. Дополнительным преимуществом является то, что, если клиент попадает в неисправное состояние, он воссоздается, чтобы последующие вызовы были успешными.

Если ServiceClient<TService> вводится в другой класс через структуру внедрения зависимостей, такую ​​как Ninject, тогда все ресурсы будут освобождены должным образом.

NB: обратите внимание, что в случае Ninject привязка должна определять область, то есть она не должна пропускать InXyzScope или определяться с помощью InTransientScope. Если область действия не имеет смысла, используйте InCallScope.

Вот что я придумал:

public class ServiceClient<TService> : IDisposable
{
    private readonly ChannelFactory<TService> channelFactory;

    private readonly Func<TService> createChannel;

    private Lazy<TService> service;

    public ServiceClient(ChannelFactory<TService> channelFactory)
        : base()
    {
        this.channelFactory = channelFactory;

        this.createChannel = () =>
        {
            var channel = ChannelFactory.CreateChannel();

            return channel;
        };

        this.service = new Lazy<TService>(() => CreateChannel());
    }

    protected ChannelFactory<TService> ChannelFactory
    {
        get
        {
            return this.channelFactory;
        }
    }

    protected Func<TService, bool> IsChannelFaulted
    {
        get
        {
            return (service) =>
                {
                    var channel = service as ICommunicationObject;

                    if (channel == null)
                    {
                        return false;
                    }

                    return channel.State == CommunicationState.Faulted;
                };
        }
    }

    protected Func<TService> CreateChannel
    {
        get
        {
            return this.createChannel;
        }
    }

    protected Action<TService> DisposeChannel
    {
        get
        {
            return (service) =>
                {
                    var channel = service as ICommunicationObject;

                    if (channel != null)
                    {
                        switch (channel.State)
                        {
                            case CommunicationState.Faulted:
                                channel.Abort();
                                break;

                            case CommunicationState.Closed:
                                break;

                            default:
                                try
                                {
                                    channel.Close();
                                }
                                catch (CommunicationException)
                                {
                                }
                                catch (TimeoutException)
                                {
                                }
                                finally
                                {
                                    if (channel.State != CommunicationState.Closed)
                                    {
                                        channel.Abort();
                                    }
                                }
                                break;
                        }
                    }
                };
        }
    }

    protected Action<ChannelFactory<TService>> DisposeChannelFactory
    {
        get
        {
            return (channelFactory) =>
                {
                    var disposable = channelFactory as IDisposable;

                    if (disposable != null)
                    {
                        disposable.Dispose();
                    }
                };
        }
    }

    public void Dispose()
    {
        DisposeChannel(this.service.Value);
        DisposeChannelFactory(this.channelFactory);
    }

    public TService Service
    {
        get
        {
            if (this.service.IsValueCreated && IsChannelFaulted(this.service.Value))
            {
                DisposeChannel(this.service.Value);

                this.service = new Lazy<TService>(() => CreateChannel());
            }

            return this.service.Value;
        }
    }
}