public CallResult<SideTestEvent> TestSide(int sideId)
        {
                return ExecuteTask(ApplyPartial<int, CancellationToken, CallResult<SideTestEvent>>(InternalTestSide, sideId), _operationTimeout);
        }

        public CallResult<SideTestEvent> InternalTestSide(int sideId, CancellationToken ct)
        {
            _logger.Debug("Worker InternalTestSide {0}", sideId);

            var dispensersTask = _proxy.GetCashedDispensersAsync();
            dispensersTask.Wait(ct);

            if (dispensersTask.IsCompleted)
            {
                var dispensers = dispensersTask.Result.ToArray();
                _logger.Debug("Worker InternalTestSide {0} LogDispensers", sideId);
                //LogDispensers(dispensers);

                var connected = dispensers.Where(_ => _.SideId == sideId && _.IsConnected).ToArray();

                if (connected.Length == 0)
                {
                    return CallResult<SideTestEvent>.Ok(new SideTestEvent {Result = SideTestResult.SideOutOfService});
                }
            ...skipped...
            }
            return CallResult<SideTestEvent>.Fail();
        }

        private static Func<T2, TResult> ApplyPartial<T1, T2, TResult>(Func<T1, T2, TResult> function, T1 arg1)
        {
            return (b) => function(arg1, b);
        }

        private CallResult<T> ExecuteTask<T>(Func<CancellationToken, CallResult<T>> action, TimeSpan operationTimeout, [CallerMemberName] string callerName = "ExecuteTask")
        {            
            CallResult<T> result;

            var needReconnect = false;

            if (_state == SupervisorState.Work && _proxy != null)
            {
                if (_proxy.State == CommunicationState.Opened)
                {
                    using (var cts2 = CancellationTokenSource.CreateLinkedTokenSource(new[] {_cts.Token}))
                    {
                        var token = cts2.Token;
                        var task = Task.Factory.StartNew(() =>
                        {
                            try
                            {
                                return action(token);
                            }
                            catch (Exception exc)
                            {
                                _logger.DebugException("Service " + callerName, exc);
                                return CallResult<T>.Fail(exc.Message);
                            }
                        }, cts2.Token);
                        task.Wait((int) operationTimeout.TotalMilliseconds, cts2.Token);
                        if (task.IsCompleted)
                        {
                            result = task.Result;
                        }
                        else
                        {
                            cts2.Cancel();
                            result = CallResult<T>.Fail("Сервер не ответил за отведенное время");
                            needReconnect = true;
                        }
                    }
                }
                else
                {
                    result = CallResult<T>.Fail("Нет связи с сервером");
                    needReconnect = true;
                }
            }
            else
            {
                result = CallResult<T>.Fail("Нет связи с сервером");
                _lastAttachError = "Нет связи с сервером";
            }

            if (needReconnect)
            {
                Reconnect();
            }
            
            return result;
        }

        private void Reconnect()
        {
            var iAmFirst = false;
            lock (_lock)
            {
                if (_state != SupervisorState.Connecting)
                {
                    iAmFirst = true;
                    _state = SupervisorState.Connecting;
                }
            }
            if (iAmFirst)
            {
                InternalDetach();
                _logger.Debug("Service Reconnect");
                Task.Factory.StartNew(ConnectLoop, TaskCreationOptions.LongRunning);
            }
        }