      - parameter U: Your delegate must implement the methods in `EntityMonitorDelegate` with the matching `CoreDataModelable` type being monitored.
      */
     public func setDelegate<U: EntityMonitorDelegate where U.T == T>(delegate: U) {
-        self.delegate = InternalEntityMonitorDelegate(delegate)
+        self.delegateHost = ForwardingEntityMonitorDelegate(owner: self, delegate: delegate)
     }
 
     // MARK: - Private Properties
 
-    private var delegate: InternalEntityMonitorDelegate<T>?
+    private var delegateHost: BaseEntityMonitorDelegate<T>? {
+        willSet {
+            delegateHost?.removeObservers()
+        }
+        didSet {
+            delegateHost?.setupObservers()
+        }
+    }
 
     private typealias EntitySet = Set<T>
 

        self.context = context
        self.frequency = frequency
        self.filterPredicate = filterPredicate
        guard let entity = NSEntityDescription.entityForName(T.entityName, inManagedObjectContext: context) else {
            entityPredicate = NSPredicate()
            return nil
        }

        entityPredicate = NSPredicate(format: "entity == %@", entity)
        setupObservers()
    }

    deinit {
        removeObservers()
    }

    // MARK: - Private

    private func setupObservers() {
        let notificationName: String
        switch frequency {
        case .OnChange:
            notificationName = NSManagedObjectContextObjectsDidChangeNotification
        case .OnSave:

        NSNotificationCenter.defaultCenter().addObserver(self,
            selector: ChangeObserverSelectorName,
            name: notificationName,
            object: owner.context)
    }

    final func removeObservers() {
        NSNotificationCenter.defaultCenter().removeObserver(self)
    }

    @objc final func evaluateChangeNotification(notification: NSNotification) {
        guard let changeSet = notification.userInfo else {
            return
        }

        owner.context.performBlockAndWait { [predicate = owner.combinedPredicate] in
            func process(value: AnyObject?) -> EntitySet {
                return value.flatMap { $0.filteredSetUsingPredicate(predicate) as? EntitySet } ?? []
            }

            let inserted = process(changeSet[NSInsertedObjectsKey])
            let deleted = process(changeSet[NSDeletedObjectsKey])
            let updated = process(changeSet[NSUpdatedObjectsKey])
            self.handleChanges(inserted: inserted, deleted: deleted, updated: updated)
        }
    }

    func handleChanges(inserted inserted: EntitySet, deleted: EntitySet, updated: EntitySet) {
        fatalError()
    }
}

private final class ForwardingEntityMonitorDelegate<Delegate: EntityMonitorDelegate>: BaseEntityMonitorDelegate<Delegate.T> {

    weak var delegate: Delegate?

    init(owner: Owner, delegate: Delegate) {
        super.init(owner: owner)
        self.delegate = delegate
    }

    override func handleChanges(inserted inserted: EntitySet, deleted: EntitySet, updated: EntitySet) {
        guard let delegate = delegate else { return }

        if !inserted.isEmpty {
            delegate.entityMonitorObservedInserts(owner, entities: inserted)
        }

        if !deleted.isEmpty {
            delegate.entityMonitorObservedDeletions(owner, entities: deleted)
        }

        if !updated.isEmpty {
            delegate.entityMonitorObservedModifications(owner, entities: updated)
        }
    }
}
