我遇到这样的错误

由于未捕获的异常“ NSInvalidArgumentException”而终止应用程序，原因：“ executeFetchRequest：错误：不是有效的NSFetchRequest。”以NSException类型的未捕获异常终止

我有一些案例，当我使用函数 func create（...） 然后调用 func read（） 用于获取我刚才保存的内容，我也不会出错，该代码也能正常工作，但是当我仅调用函数 func read（） 时，我就是出现错误：

由于未捕获的异常“ NSInvalidArgumentException”而终止应用程序，原因：“ executeFetchRequest：错误：不是有效的NSFetchRequest。”以NSException类型的未捕获异常终止

我的直觉是当对象对我的实体（上载ManagaerEntity）进行数据处理时出现的错误

这是我的课程 CoreDataContext.swift

import Foundation
import CoreData

public protocol CoreDataContextProtocol {
    associatedtype ObjectType
    associatedtype PredicateType
    var xcDataModelName: String { get }

    func save(_ object: ObjectType,completion: @escaping (Result<String,Error>) -> Void)
    func read(_ objectType: ObjectType.Type,predicate: PredicateType?,limit: Int?) -> Result<[ObjectType],Error>
    func delete(_ object: ObjectType,Error>) -> Void)
    func truncate(_ object: ObjectType.Type,Error>) -> Void)
}

public extension CoreDataContextProtocol {
    func read(_ objectType: ObjectType.Type,predicate: PredicateType? = nil,limit: Int? = nil) -> Result<[ObjectType],Error> {
        return read(objectType,predicate: predicate,limit: limit)
    }
}

class CoreDataContext: CoreDataContextProtocol {
    typealias ObjectType = NSManagedObject
    typealias PredicateType = NSPredicate
    var xcDataModelName: String { get { return "DataKoda" } }
    
    static let shared = CoreDataContext()
    var context: NSmanagedobjectcontext { persistentContainer.viewContext }
    private init() { }
    
    // MARK: -  DBHelper Protocol
    func save(_ object: NSManagedObject,Error>) -> Void) {
        do {
            try context.save()
            completion(.success("Success saving data \(object.description)"))
        } catch let err {
            completion(.failure(err))
        }
    }
    
    func read<T: NSManagedObject>(_ objectType: T.Type,predicate: NSPredicate? = nil,limit: Int? = nil) -> Result<[T],Error> {
        let request = objectType.fetchRequest()
        request.returnsObjectsAsFaults = false
        if let predicate = predicate {
            request.predicate = predicate
        }
        if let limit = limit {
            request.fetchLimit = limit
        }
        do {
            let result = try context.fetch(request)
            return .success(result as? [T] ?? [])
        } catch {
            return .failure(error)
        }
    }
    
    func delete(_ object: NSManagedObject,Error>) -> Void) {
        context.delete(object)
        save(object) { (result) in
            completion(result)
        }
    }
    
    func truncate<T: NSManagedObject>(_ object: T.Type,Error>) -> Void) {
        let request = NSBatchDeleteRequest(fetchRequest: object.fetchRequest())
        do {
            try context.execute(request)
            completion(.success("Success delete data \(object)"))
        } catch {
            completion(.failure(error))
        }
    }
    
    // MARK: - Core Data
    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: xcDataModelName)
        container.loadPersistentStores(completionHandler: { (storeDescription,error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error),\(error.userInfo)")
            }
        })
        return container
    }()

    func saveContext () {
        let context = persistentContainer.viewContext
        if context.hasChanges {
            do {
                try context.save()
            } catch {
                let nserror = error as NSError
                fatalError("Unresolved error \(nserror),\(nserror.userInfo)")
            }
        }
    }
}

这是我的最后一堂课 DataManager.swift

protocol DataManagerProtocol {
    associatedtype EntityFinal: NSManagedObject
    var coreDataContext: CoreDataContext { get }
    var entityName: String { get }
    
    func getEntityDesc(context: NSmanagedobjectcontext) -> NSEntityDescription?
    func create(params: [String: Any])
    func read(predicate: NSPredicate?,limit: Int?) -> [EntityFinal]
    func update(params: [String: Any],_ object: EntityFinal)
    func truncate()
}

extension DataManagerProtocol {
    var coreDataContext: CoreDataContext { get { return CoreDataContext.shared } }
    var entityName: String { get { return String(describing: EntityFinal.self) } }
    
    func getEntityDesc(context: NSmanagedobjectcontext) -> NSEntityDescription? {
        let entity = NSEntityDescription.entity(forEntityName: self.entityName,in: context)
        return entity
    }
    
    func create(params: [String: Any]) {
        let entity = getEntityDesc(context: coreDataContext.context)
        let new = EntityFinal(entity: entity!,insertInto: coreDataContext.context)
        let keys = new.entity.attributesByName.keys
        for key in keys {
            debugLog(key)
            new.setvalue(params[key],forKey: key)
        }
        coreDataContext.save(new) { (result) in
            switch result {
            case .failure(let err):
                debugLog(err.localizedDescription)
            case .success(let res):
                debugLog(res)
            }
        }
    }
    
    func read(predicate: NSPredicate? = nil,limit: Int? = nil) -> [UploadManagerEntity] {
        let result: Result<[UploadManagerEntity],Error> = coreDataContext.read(UploadManagerEntity.self,limit: limit)
        switch result {
        case .failure(let err):
            debugLog(err.localizedDescription)
            return []
        case .success(let res):
            debugLog(res)
            return res
        }
    }
    
    func delete(_ object: EntityFinal) {
        coreDataContext.delete(object) { (result) in
            switch result {
            case .failure(let err):
                debugLog(err.localizedDescription)
            case .success(let res):
                debugLog(res)
            }
        }
    }
    
    func truncate() {
        coreDataContext.truncate(EntityFinal.self) { (result) in
            switch result {
            case .failure(let err):
                debugLog(err.localizedDescription)
            case .success(let res):
                debugLog(res)
            }
        }
    }
}

// MARK: - DataManagerProtocol
final class DataManager: DataManagerProtocol {
    typealias EntityFinal = UploadManagerEntity
    
    static let shared: DataManager = DataManager()
    private init() { }
    
    func update(params: [String : Any],_ object: UploadManagerEntity) {
        let predicate = NSPredicate(
            format: "submission_id = %@",(object.submission_id ?? "") as CVarArg
        )
        guard let result = read(predicate: predicate,limit: 1).first else { return }
        let keys = result.entity.attributesByName.keys
        for key in keys {
            debugLog("update",key)
            result.setvalue(params[key],forKey: key)
        }
        coreDataContext.save(result) { (result) in
            switch result {
            case .failure(let err):
                debugLog(err.localizedDescription)
            case .success(let res):
                debugLog(res)
            }
        }
    }
}

我对bcs感到困惑，认为有人提出建议或建议，如何解决？