我有一个NSFetchedResultsController，我正在尝试在后台上下文中更新我的数据。例如，这里我试图删除一个对象：
persistentContainer.performBackgroundTask { context in
let object = context.object(with: restaurant.objectID)
context.delete(object)
try? context.save()
}
有两件事我不明白：
NSFetchedResultsController 会在后台内容保存到其父级时进行更新，但这并没有发生。我需要在主线程上手动触发一些东西吗？显然有些东西我没有得到。谁能解释一下？
我知道我已经正确实现了获取结果控制器委托方法，因为如果我将代码更改为直接更新viewContext，一切都会按预期工作。
【问题讨论】：
NSPersistentContainer 的实例方法 performBackgroundTask(_:) 和 newBackgroundContext() 记录不充分。
无论您调用哪种方法，在任何一种情况下，（返回的）临时NSManagedObjectContext 都使用privateQueueConcurrencyType 设置并直接与NSPersistentStoreCoordinator 关联，因此没有parent。
调用此方法会导致持久化容器创建并 返回一个新的 NSManagedObjectContext 并将 concurrencyType 设置为 私有队列并发类型。这个新的上下文将与 NSPersistentStoreCoordinator 直接并设置为使用 NSManagedObjectContextDidSave 自动广播。
...或自己确认：
persistentContainer.performBackgroundTask { (context) in
print(context.parent) // nil
print(context.persistentStoreCoordinator) // Optional(<NSPersistentStoreCoordinator: 0x...>)
}
let context = persistentContainer.newBackgroundContext()
print(context.parent) // nil
print(context.persistentStoreCoordinator) // Optional(<NSPersistentStoreCoordinator: 0x...>)
由于缺少parent，更改不会提交给parent context，例如viewContext 和 viewContext 未触及，连接的 NSFetchedResultsController 不会识别任何更改，因此不会更新或调用其 delegate 的方法。相反，更改将直接推送到persistent store coordinator，然后保存到persistent store。
我希望我能够为您提供帮助，如果您需要进一步的帮助，我可以在我的回答中添加如何获得您所描述的所需行为。 （解决方案添加在下方）
您通过使用两个具有父子关系的NSManagedObjectContexts 来实现您所描述的行为：
// Create new context for asynchronous execution with privateQueueConcurrencyType
let backgroundContext = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
// Add your viewContext as parent, therefore changes are pushed to the viewContext, instead of the persistent store coordinator
let viewContext = persistentContainer.viewContext
backgroundContext.parent = viewContext
backgroundContext.perform {
// Do your work...
let object = backgroundContext.object(with: restaurant.objectID)
backgroundContext.delete(object)
// Propagate changes to the viewContext -> fetched results controller will be notified as a consequence
try? backgroundContext.save()
viewContext.performAndWait {
// Save viewContext on the main queue in order to store changes persistently
try? viewContext.save()
}
}
不过，您也可以坚持使用performBackgroundTask(_:) 或使用newBackgroundContext()。但如前所述，在这种情况下，更改会直接保存到持久存储中，默认情况下不会更新 viewContext。为了将更改向下传播到viewContext，从而通知NSFetchedResultsController，您必须将viewContext.automaticallyMergesChangesFromParent 设置为true：
// Set automaticallyMergesChangesFromParent to true
persistentContainer.viewContext.automaticallyMergesChangesFromParent = true
persistentContainer.performBackgroundTask { context in
// Do your work...
let object = context.object(with: restaurant.objectID)
context.delete(object)
// Save changes to persistent store, update viewContext and notify fetched results controller
try? context.save()
}
请注意，一次添加 10.000 个对象等大量更改可能会使您的 NSFetchedResultsController 发疯，从而阻止 main queue。
【讨论】：
NSPersistentContainer 在后台上下文中保存 10,000 多个对象时，有没有办法不阻塞主队列？我知道我们可以手动设置堆栈并将后台上下文链接到存储协调器，但是，我还没有找到使用容器实现此目的的方法。有人处理过这个吗？
除非您将视图上下文设置为自动合并来自父级的更改，否则视图上下文不会更新。 viewContext 已设置为您从 NSPersistentContainer 收到的任何 backgroundContext 的子级。
尝试只添加这一行：
persistentContainer.viewContext.automaticallyMergesChangesFromParent = true
现在，viewContext 将在 backgroundContext 保存后更新，这将触发 NSFetchedResultsController 更新。
【讨论】：
这在我的项目中非常适合我。 在函数 updateEnglishNewsListener(:) 中，这里的参数数据在任意对象中，我进一步将其转换为 json 格式以保存。
Core Data 使用线程（或序列化队列）限制来保护托管对象和托管对象上下文（请参阅 Core Data 编程指南）。这样做的结果是，上下文假定默认所有者是分配它的线程或队列——这由调用其 init 方法的线程确定。因此，您不应该在一个线程上初始化上下文，然后将其传递给另一个线程。
一共有三种 1. ConfinementConcurrencyType 2. PrivateQueueConcurrencyType 3. MainQueueConcurrencyType
MainQueueConcurrencyType 创建一个与主队列关联的上下文，非常适合与 NSFetchedResultsController 一起使用。
在 updateEnglishNewsListener(:) 函数中，参数数据是您的输入。 （数据->您要更新的数据。）
private func updateEnglishNewsListener(data: [AnyObject] ){
//Here is your data
let privateAsyncMOC_En = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
// The context is associated with the main queue, and as such is tied into the application’s event loop, but it is otherwise similar to a private queue-based context. You use this queue type for contexts linked to controllers and UI objects that are required to be used only on the main thread.
privateAsyncMOC_En.parent = managedObjectContext
privateAsyncMOC_En.perform{
// The perform(_:) method returns immediately and the context executes the block methods on its own thread. Here it use background thread.
let convetedJSonData = self.convertAnyobjectToJSON(anyObject: data as AnyObject)
for (_ ,object) in convetedJSonData{
self.checkIFNewsIdForEnglishAlreadyExists(newsId: object["news_id"].intValue, completion: { (count) in
if count != 0{
self.updateDataBaseOfEnglishNews(json: object, newsId: object["news_id"].intValue)
}
})
}
do {
if privateAsyncMOC_En.hasChanges{
try privateAsyncMOC_En.save()
}
if managedObjectContext.hasChanges{
try managedObjectContext.save()
}
}catch {
print(error)
}
}
}
检查coredata中是否已经存在数据以避免冗余数据。 Coredata 没有主键概念，所以我们依次检查数据是否已经存在于 coredata 中。当且仅当更新数据已存在于 coredata 中时，才会更新数据。这里 checkIFNewsIdForEnglishAlreadyExists(:) 函数返回 0 或 value 。如果它返回 0，则数据不保存在数据库中，否则保存。我正在使用完成句柄来了解新数据或旧数据。
private func checkIFNewsIdForEnglishAlreadyExists(newsId:Int,completion:(_ count:Int)->()){
let fetchReq:NSFetchRequest<TestEntity> = TestEntity.fetchRequest()
fetchReq.predicate = NSPredicate(format: "news_id = %d",newsId)
fetchReq.fetchLimit = 1 // this gives one data at a time for checking coming data to saved data
do {
let count = try managedObjectContext.count(for: fetchReq)
completion(count)
}catch{
let error = error as NSError
print("\(error)")
completion(0)
}
}
根据需要将旧数据替换为新数据。
private func updateDataBaseOfEnglishNews(json: JSON, newsId : Int){
do {
let fetchRequest:NSFetchRequest<TestEntity> = TestEntity.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "news_id = %d",newsId)
let fetchResults = try managedObjectContext.fetch(fetchRequest as! NSFetchRequest<NSFetchRequestResult>) as? [TestEntity]
if let fetchResults = fetchResults {
if fetchResults.count != 0{
let newManagedObject = fetchResults[0]
newManagedObject.setValue(json["category_name"].stringValue, forKey: "category_name")
newManagedObject.setValue(json["description"].stringValue, forKey: "description1")
do {
if ((newManagedObject.managedObjectContext?.hasChanges) != nil){
try newManagedObject.managedObjectContext?.save()
}
} catch {
let saveError = error as NSError
print(saveError)
}
}
}
} catch {
let saveError = error as NSError
print(saveError)
}
}
将任何对象转换为 JSON 以保存在 coredata 中
func convertAnyobjectToJSON(anyObject: AnyObject) -> JSON{
let jsonData = try! JSONSerialization.data(withJSONObject: anyObject, options: JSONSerialization.WritingOptions.prettyPrinted)
let jsonString = NSString(data: jsonData, encoding: String.Encoding.utf8.rawValue)! as String
if let dataFromString = jsonString.data(using: String.Encoding.utf8, allowLossyConversion: false) {
let json = JSON(data: dataFromString)
return json
}
return nil
}
希望对您有所帮助。如果有任何困惑，请询问。
【讨论】：