在核心数据模型上创建通用包装器是一种不好的做法吗？

Question

我正在研究 Swift 和 Core Data，我计划为我的模型使用一个简单的包装器。

此时，协议和扩展如下所示：

protocol CRUD {
    associatedtype T: NSManagedObject

    var context: NSManagedObjectContext { get }

    var items: [T]! { get set }

    func getAll() -> [T]
    mutating func addOrUpdate(_ item: T) -> T
    mutating func delete(_ item: T)
}


extension CRUD where T: NSManagedObject {
    var context: NSManagedObjectContext {
        return (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext
    }

    func save() {
        do {
            try context.save()
        } catch {
            fatalError("Saving of \(String(describing: self)) failed")
        }
    }

    func getAll() -> [T] {
        let fetchRequest = NSFetchRequest<T>(entityName: String(describing: T.self))
        let list: [T]

        do {
            list = try context.fetch(fetchRequest)
        } catch {
            fatalError("Fetching of \(String(describing: self)) failed")
        }

        return list
    }

    mutating func delete(_ item: T) {
        if let index = items.index(of: item) {
            items.remove(at: index)
        }

        context.delete(item)
        save()
    }

    mutating func addOrUpdate(_ item: T) -> T {
        if (items.contains(item)) {
            items.append(item)
        }

        save()
        return item
    }
}

每个模型的声明如下：

class TaskModel : CRUD {
    typealias T = Task

    var items: [Task]! 

    init() {
        self.items = getAll()
    }
}

这段代码在多大程度上符合 OOP 的原则（特别是，我可以将此协议称为 DAO 模式的实现）吗？需要这样的包装吗？或者Core Data是否意味着在代码中直接使用模型？

未来它可能会暴露出哪些问题？

我将非常感谢更有经验的 iOS 开发人员的建议。先感谢您。

Answer 1

对于这种功能来说，协议可能太多了，因为协议的主要目标仍然是多态性。您可以使用通用结构来代替：

struct CRUD<T: NSManagedObject> {

    var context: NSManagedObjectContext {
        return (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext
    }

    var items = [T]()

    // let's provide two approaches for initialization
    init() {
        self.init(items: getAll())
    }

    init(items: [T]) {
        self.items = items
    }

    func save() {
        do {
            try context.save()
        } catch {
            fatalError("Saving of \(String(describing: self)) failed")
        }
    }

    func getAll() -> [T] {
        let fetchRequest = NSFetchRequest<T>(entityName: String(describing: T.self))
        let list: [T]

        do {
            list = try context.fetch(fetchRequest)
        } catch {
            fatalError("Fetching of \(String(describing: self)) failed")
        }

        return list
    }

    mutating func delete(_ item: T) {
        if let index = items.index(of: item) {
            items.remove(at: index)
        }

        context.delete(item)
        save()
    }

    mutating func addOrUpdate(_ item: T) -> T {
        if (items.contains(item)) {
            items.append(item)
        }

        save()
        return item
    }
}

然后你可以在你的课堂上使用它：

class TaskModel {
    // making sure no-one from outside can mutate our CRUD
    private(set) lazy var crud = CRUD<Task>()

    init() {
        // nothing to do here, the items are already populated
    }
}

let model = TaskModel()
// the following won't compile
model.crud.delete(someTask)

IMO，这更好地传达了在 CoreData 上使用 Facade 的意图。