[ServiceContract]
    public interface IMyService
    {
        [OperationContract]
        bool DoWork();
    }

-----------

    public class Repository
    {
        public OperationResult<bool> DoWork()
        {
            var wrapper = new ServiceWrapper();
            wrapper.DoWork();
            return new ServiceOperationResult(wrapper);
        }
    }
 
    public class ServiceWrapper : INotifyCompleted, INotifyCompletedArgs
    {
        private DoWorkCompletedEventArgs _args;
        private Action<INotifyCompletedArgs> _notifyActions;
        private readonly MyServiceClient _service;
 
        public ServiceWrapper()
        {
            _service = new MyServiceClient();    
        }
 
        /// <summary>
        /// Action to be performed when the asynchronous operation completes.
        /// </summary>
        /// <param name="completedAction"/>
        public void WhenCompleted(Action<INotifyCompletedArgs> completedAction)
        {
            if (completedAction == null) return;
            if (_args != null)

            {
                completedAction(this);
                return;
            }
            _notifyActions = (Action<INotifyCompletedArgs>)Delegate.Combine(_notifyActions, completedAction);
        }
 
        public void DoWork()
        {
            _service.DoWorkCompleted += ServiceOnDoWorkCompleted;
            _service.DoWorkAsync();
        }
 
        private void ServiceOnDoWorkCompleted(object sender, DoWorkCompletedEventArgs args)
        {
            _args = args;
            _service.DoWorkCompleted -= ServiceOnDoWorkCompleted;
            _service.CloseAsync();
 
            // Notify subscribers
            var actions = _notifyActions;
            _notifyActions = null;
            if (actions == null) return;
            actions(this);
        }
 
        public bool Result
        {
            get { return _args != null && _args.Result; }
        }
 
        /// <summary>
        /// The exception if the action failed.
        /// </summary>
        public Exception Error { get { return _args != null ? _args.Error : null; } }
 
        /// <summary>
        /// Whether the action was cancelled.
        /// </summary>
        public bool Cancelled { get { return _args != null && _args.Cancelled; } }
 
        /// <summary>
        /// Whether the error was handled.
        /// </summary>
        public bool IsErrorHandled { get; set; }
    }
 
    public class ServiceOperationResult : OperationResult<bool>
    {
        private readonly ServiceWrapper _wrapper;
 
        public ServiceOperationResult(ServiceWrapper wrapper)
            : base(wrapper)
        {
            _wrapper = wrapper;
        }
 
        /// <summary>
        /// The result value of the operation.
        /// </summary>
        public override bool Result
        {
            get { return _wrapper.Result; }
        }
    }