     public final func rebind() -> TBoundType {
         // Update the current value
         let currentValue    = computeValue();
+        
+        _bindingUpdateSemaphore.wait();
         _currentValue       = currentValue;
+        _bindingUpdateSemaphore.signal();
         
         return currentValue;
+    }
+    
+    ///
+    /// Retrieves the current vaue of this bound value, or nil if it is currently unresolved
+    ///
+    @inline(__always)
+    public final func getCurrentValue() -> TBoundType? {
+        _bindingUpdateSemaphore.wait();
+        let result = _currentValue;
+        _bindingUpdateSemaphore.signal();
+        return result;
     }
     
     ///

            let isNowBound = _actionsOnChanged.count > 0;
            _bindingUpdateSemaphore.signal();
            
            isBound.value = isNowBound;
        }
    }

        // Resolving a binding creates a dependency in the current context
        BindingContext.current?.addDependency(self);
        
        if let currentValue = getCurrentValue() {
            return currentValue;
        } else {
            return rebind();
        }
    }
    
    ///
    /// Mark this item as having been changed
    ///
    /// The next time the value is resolved, it will register as a change and the observers will be called.
    ///
    open func markAsChanged() {
        // Notify a change if we're currently resolved (otherwise, assume that the change is still pending and we don't need to notify again)
        _bindingUpdateSemaphore.wait();
        
        if _currentValue != nil {
            _currentValue = nil;
            _bindingUpdateSemaphore.signal();
            
            notifyChange();
        } else {
            _bindingUpdateSemaphore.signal();
        }
    }
    
