CloudKit同步无法随Toggle开关即时关闭，需重启应用的解决问询

问题分析 #

你当前的实现中，关闭Toggle后仅重新创建了NSPersistentCloudKitContainer并设置cloudKitContainerOptions = nil，但旧容器的持久化存储仍被NSPersistentStoreCoordinator管理，CloudKit的同步进程会在后台继续运行，直到App重启才会终止。要实现立即停止同步，必须先卸载旧容器的持久化存储，再加载新的无CloudKit配置的容器。

解决方案步骤 #

1. 给CoreDataManager添加卸载旧持久化存储的方法，确保旧容器的同步进程终止
2. 更新CoreDataManager的上下文管理，确保切换容器后使用新的上下文
3. 修改ViewModel的容器更新逻辑，先卸载旧容器再加载新容器
4. 简化设置视图的开关响应逻辑

修改后的代码实现 #

1. 改进CoreDataManager

class CoreDataManager{
    // Singleton
    static let instance = CoreDataManager()
    
    @AppStorage(UserDefaults.Keys.iCloudSyncKey) private var iCloudSync = false

    static var preview: CoreDataManager = {
        // Create preview objects
        let result = CoreDataManager(inMemory: true)
        do {
            try result.context.save()
        } catch {
            print("Preview save error: \(error)")
        }
        return result
    }()
    
    // 改为可变属性，确保切换容器后更新上下文
    var context: NSManagedObjectContext!
    
    lazy var container: NSPersistentContainer = {
        setupContainer()
    }()
    
    init(inMemory: Bool = false){
        if inMemory {
            container.persistentStoreDescriptions.first!.url = URL(fileURLWithPath: "/dev/null")
        }
    }
    
    // 新增：卸载旧持久化存储，终止同步进程
    func tearDownContainer() {
        // 先保存未提交的更改
        if context?.hasChanges == true {
            do {
                try context.save()
            } catch {
                print("Failed to save context before teardown: \(error)")
            }
        }
        
        guard let storeURL = container.persistentStoreDescriptions.first?.url else { return }
        do {
            try container.persistentStoreCoordinator.removePersistentStore(at: storeURL)
        } catch {
            print("Failed to remove persistent store: \(error)")
        }
    }
    
    func setupContainer()->NSPersistentContainer{
        print("Assigning persistent container... ")
        let container = NSPersistentCloudKitContainer(name: "CoreDataContainer")
        
        guard let description = container.persistentStoreDescriptions.first else{
            fatalError("###\(#function): Failed to retrieve a persistent store description.")
        }
        
        description.setOption(true as NSNumber, forKey: NSPersistentHistoryTrackingKey)
        description.setOption(true as NSNumber, forKey: NSPersistentStoreRemoteChangeNotificationPostOptionKey)
        
        if iCloudSync{
            let cloudKitContainerIdentifier = "iCloud.com.sitename.myApp"
            let options = NSPersistentCloudKitContainerOptions(containerIdentifier: cloudKitContainerIdentifier)
            description.cloudKitContainerOptions = options
        }else{
            description.cloudKitContainerOptions = nil
        }
        
        container.loadPersistentStores { (description, error) in
            if let error = error{
                print("Error loading Core Data. \(error)")
            }
        }
        container.viewContext.automaticallyMergesChangesFromParent = true
        container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
        
        // 更新上下文为新容器的viewContext
        self.context = container.viewContext
        
        return container
    }
    
    func save(){
        guard let context = context else { return }
        do{
            try context.save()
        }catch let error{
            print("Error saving Core Data. \(error.localizedDescription)")
        }
    }
}

2. 改进CarViewModel

class CarViewModel: ObservableObject{
    let manager: CoreDataManager
    
    @Published var cars: [Car] = []
    
    init(coreDataManager: CoreDataManager = .instance){
        self.manager = coreDataManager
        loadCars()
    }
    
    func updateCloudKitContainer(){
        // 先卸载旧容器，终止同步
        manager.tearDownContainer()
        // 加载新容器
        manager.container = manager.setupContainer()
        // 重新加载数据，确保使用新上下文
        loadCars()
    }

    func addCar(model:String, make:String?){
        let newCar = Car(context: manager.context)
        newCar.model = model
        newCar.make = make
        save()
        loadCars()
    }

    func deleteCar(car: Car){
        manager.context.delete(car)
        save()
        loadCars()
    }

    func loadCars(){
        let request = NSFetchRequest<Car>(entityName: "Car")
        let sort = NSSortDescriptor(keyPath: \Car.model, ascending: true)
        request.sortDescriptors = [sort]
        do{
            cars = try manager.context.fetch(request)
        }catch let error{
            print("Error fetching cars. \(error.localizedDescription)")
        }
    }

    func save(){
        self.manager.save()
    }
}

3. 简化SettingsView

struct SettingsView: View {
    @ObservedObject var carViewModel:CarViewModel
    @AppStorage(UserDefaults.Keys.iCloudSyncKey) private var iCloudSync = false
    
    var body: some View {
        VStack{
            Toggle(isOn: $iCloudSync){
                HStack{
                    Image(systemName: iCloudSync ? "arrow.counterclockwise.icloud" : "lock.icloud")
                        .foregroundColor(Color.fsRed)
                    Text(" iCloud Sync")
                }
            }
            .tint(Color.fsRed)
            .onChange(of: iCloudSync){ _ in
                carViewModel.updateCloudKitContainer()
            }
        }
    }
}

关键说明 #

• 卸载持久化存储：调用persistentStoreCoordinator.removePersistentStore(at:)会终止旧容器与CloudKit的同步连接，彻底停止后台同步进程
• 更新上下文：将context从lazy改为可变属性，确保切换容器后所有Core Data操作都使用新容器的上下文
• 保存未提交更改：在卸载存储前保存上下文，避免数据丢失

内容的提问来源于stack exchange，提问作者fs_tigre