    // MARK: - Public
    @discardableResult public func get(observer: ConductionResourceObserver? = nil, priority: Int? = nil, completion: @escaping (_ resource: Resource?) -> Void) -> ConductionResourceObserver {
       let observer = observer ?? ConductionResourceObserver()
-      dispatchQueue.async {
+      dispatch {
          self.directGet(observer: observer, priority: priority, completion: completion)
       }
       return observer

      }
      
      fetchBlock(state) { [weak self] input in
         self?.dispatchQueue.async {
            guard let strongSelf = self else { return }
            switch strongSelf.state {
            case .fetching(let newID, _):


   @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()
      dispatch {
         self.directObserveState(observer: observer, priority: priority, completion: completion)
      }
      return observer
   }

   public func forget(_ observer: ConductionResourceObserver) {
     dispatch {
         self.directForget(observer)
      }
   }
   
   public func forgetAll() {
      dispatch {
         self.directForgetAll()
      }
   }
   
   public func check(completion: @escaping (_ state: ConductionResourceState<Input, Resource>, _ priority: Int?, _ input: Input?, _ resource: Resource?) -> Void) {
      dispatch {
         self.directCheck(completion: completion)
      }
   }
   
   public func load() {
      dispatch {
         self.directLoad()
      }
   }

   public func reload() {
      dispatch {
         self.directReload()
      }
   }

   public func clear() {
      dispatch {
         self.directClear()
      }
   }
   
   public func expire() {
      dispatch {
         self.directExpire()
      }
   }
   
   public func invalidate() {
      dispatch {
         self.directInvalidate()
      }
   }
   
   public func setInput( _ input: Input?) {
      dispatch {
         self.directSetInput(input)
      }
   }
   
   public func setResource(_ resource: Resource?) {
      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
