         self.registration = { param in registration(param as! P) }
     }
     
-    func resolve<T>(parameter: Any, cached: Bool) -> T {
+    func resolve<T>(parameter: Any, cached: Bool?) -> T {
         var result: T
-        if cached {
+        if cached ?? self.cached {
             if instance == nil {
                 instance = registration(parameter)
             }

        - container: The container in which to register the block.
        - cached: Whether or not to cache the result of the registration block.
        - registration: The block to register with Guise.
    */
    public static func register<P, T, N: Hashable, C: Hashable>(name: N, container: C, cached: Bool = false, registration: @escaping Registration<P, T>) -> Key {
        return register(key: Key(type: T.self, name: name, container: container), cached: cached, registration: registration)

    private static var lock = Lock()
    private static var registrations = [Key: Dependency]()
    
    private static func register<P, T>(key: Key, cached: Bool = false, registration: @escaping Registration<P, T>) -> Key {
        lock.write { registrations[key] = Dependency(cached: cached, registration: registration) }
        return key
    }
    
    /**
     Register the `registration` block with the type `T` in the given `name` and `container`.
     
     - returns: The unique `Key` for this registration.
     
