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

Question

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

此时，协议(protocol)和扩展如下所示:

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的原则(特别是，我可以把这个协议(protocol)称为DAO模式的实现)？需要这样的包装器吗？或者 Core Data 是否意味着在代码中直接使用模型？

future 它能揭示出哪些可能的问题？

我将非常感谢更有经验的 iOS 开发人员的建议。提前谢谢你。

Answer 1

协议(protocol)对于这种功能来说可能太多了，因为协议(protocol)的主要目标仍然是多态性。您可以改用通用结构:

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 的意图。