 
    @discardableResult public func observeState(observer: ConductionResourceObserver? = nil, priority: Int? = nil, completion: @escaping (_ oldState: ConductionResourceState<Input, Resource>, _ newState: ConductionResourceState<Input, Resource>) -> Void) -> ConductionResourceObserver {
       let observer = observer ?? ConductionResourceObserver()
-      dispatchQueue.async {
+      dispatch {
          self.directObserveState(observer: observer, priority: priority, completion: completion)
       }
       return observer
    }
 
    public func forget(_ observer: ConductionResourceObserver) {
-      dispatchQueue.async {
+     dispatch {
          self.directForget(observer)
       }
    }
    
    public func forgetAll() {
-      dispatchQueue.async {
+      dispatch {
          self.directForgetAll()
       }
    }
    
    public func check(completion: @escaping (_ state: ConductionResourceState<Input, Resource>, _ priority: Int?, _ input: Input?, _ resource: Resource?) -> Void) {
-      dispatchQueue.async {
+      dispatch {
          self.directCheck(completion: completion)
       }
    }
    
    public func load() {
-      dispatchQueue.async {
+      dispatch {
          self.directLoad()
       }
    }
 
    public func reload() {
-      dispatchQueue.async {
+      dispatch {
          self.directReload()
       }
    }
 
    public func clear() {
-      dispatchQueue.async {
+      dispatch {
          self.directClear()
       }
    }
    
    public func expire() {
-      dispatchQueue.async {
+      dispatch {
          self.directExpire()
       }
    }
    
    public func invalidate() {
-      dispatchQueue.async {
+      dispatch {
          self.directInvalidate()
       }
    }
    
    public func setInput( _ input: Input?) {
-      dispatchQueue.async {
+      dispatch {
          self.directSetInput(input)
       }
    }
    
    public func setResource(_ resource: Resource?) {
-      dispatchQueue.async {
+      dispatch {
          self.directSetResource(resource)
       }
    }
    
+   public func dispatch(_ block: @escaping () -> Void) {
+      if dispatchQueue.getSpecific(key: _dispatchKey) != nil {
+         block()
+      } else {
+         dispatchQueue.async {
+            block()
+         }
+      }
+   }
+
    // MARK: - Direct
    open func directTransition(newState: ConductionResourceState<Input, Resource>) {
       let oldState = state

   
   // MARK: - Init
   public init(dispatchQueue: DispatchQueue = .main, defaultPriority: Int = 0, fetchBlock: ConductionResourceFetchBlock<Input, Resource>? = nil, transformBlock: ConductionResourceTransformBlock<Input, Resource>? = nil, commitBlock: @escaping ConductionResourceCommitBlock<Input, Resource> = { _, nextState in return nextState }) {
      self.dispatchQueue = dispatchQueue
      self.defaultPriority = defaultPriority
      self.fetchBlock = fetchBlock

      }
      
      transformBlock(state) { [weak self] resource in
         self?.dispatch {
            guard let strongSelf = self else { return }
            switch strongSelf.state {
            case .processing(let newID, _, _):
