SwiftUI中如何等待CloudKit与Core Data同步后再请求数据？

下面提供几种可靠的方案替代延时等待，精准监听同步完成状态：

方法1：监听NSPersistentCloudKitContainer同步事件通知 #

NSPersistentCloudKitContainer会在同步状态变化时发送NSPersistentCloudKitContainer.eventChangedNotification通知，通过解析通知中的事件可以判断初始导入是否完成。

代码示例 #

import SwiftUI
import CoreData
import Combine

struct ContentView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @State private var isSyncCompleted = false
    private var cancellables = Set<AnyCancellable>()
    
    var body: some View {
        Group {
            if isSyncCompleted {
                List {
                    // 同步完成后渲染Core Data数据
                    ForEach(fetchData()) { item in
                        Text(item.title ?? "")
                    }
                }
            } else {
                ProgressView("正在同步iCloud数据...")
            }
        }
        .onAppear {
            setupSyncListener()
        }
    }
    
    private func fetchData() -> [YourEntity] {
        let request = YourEntity.fetchRequest()
        do {
            return try viewContext.fetch(request)
        } catch {
            print("数据获取失败：\(error.localizedDescription)")
            return []
        }
    }
    
    private func setupSyncListener() {
        NotificationCenter.default.publisher(for: NSPersistentCloudKitContainer.eventChangedNotification)
            .receive(on: DispatchQueue.main)
            .sink { notification in
                guard let event = notification.userInfo?[NSPersistentCloudKitContainerEventNotificationKey] as? NSPersistentCloudKitContainerEvent else {
                    return
                }
                
                // 判断是否完成初始iCloud数据导入
                if event.type == .import && event.endDate != nil && event.progress == 1.0 {
                    isSyncCompleted = true
                }
            }
            .store(in: &cancellables)
    }
}

// Core Data持久化控制器示例
class PersistenceController {
    static let shared = PersistenceController()
    let container: NSPersistentCloudKitContainer
    
    init() {
        container = NSPersistentCloudKitContainer(name: "YourDataModel")
        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Core Data加载失败：\(error), \(error.userInfo)")
            }
        })
    }
}

方法2：主动检查同步完成状态 #

通过fetchCloudKitContainerEvents查询历史同步事件，结合当前是否有活跃同步任务，判断初始同步是否完成。

代码示例 #

extension PersistenceController {
    func checkInitialSyncStatus(completion: @escaping (Bool) -> Void) {
        container.fetchCloudKitContainerEvents(from: Date.distantPast, to: Date()) { events, error in
            guard let events = events, error == nil else {
                completion(false)
                return
            }
            
            // 检查是否有已完成的导入事件
            let hasCompletedImport = events.contains {
                $0.type == .import && $0.endDate != nil && $0.progress == 1.0
            }
            
            // 检查是否存在活跃同步任务
            self.container.persistentStoreCoordinator.performAndWait {
                let hasActiveTasks = self.container.persistentStoreDescriptions.contains { desc in
                    guard let options = desc.cloudKitContainerOptions else { return false }
                    return self.container.isSyncing(for: options.containerIdentifier)
                }
                
                completion(hasCompletedImport && !hasActiveTasks)
            }
        }
    }
}

// 在View中调用检查逻辑
struct ContentView: View {
    @State private var isSyncCompleted = false
    let persistenceController = PersistenceController.shared
    
    var body: some View {
        Group {
            if isSyncCompleted {
                DataDisplayView()
            } else {
                ProgressView("同步中...")
            }
        }
        .onAppear {
            persistenceController.checkInitialSyncStatus { completed in
                DispatchQueue.main.async {
                    isSyncCompleted = completed
                }
            }
        }
    }
}

方法3：监听Managed Object Context远程变更 #

当CloudKit数据同步到Core Data时，viewContext会触发NSManagedObjectContextObjectsDidChangeNotification通知，可结合业务逻辑判断同步是否完成（比如检查目标实体的数量是否符合预期）。

代码示例 #

struct ContentView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @State private var isSyncCompleted = false
    private var cancellables = Set<AnyCancellable>()
    
    var body: some View {
        // 界面代码
    }
    
    private func setupChangeListener() {
        NotificationCenter.default.publisher(for: NSManagedObjectContext.objectsDidChangeNotification, object: viewContext)
            .receive(on: DispatchQueue.main)
            .sink { _ in
                checkSyncCompletion()
            }
            .store(in: &cancellables)
    }
    
    private func checkSyncCompletion() {
        let request = YourEntity.fetchRequest()
        request.resultType = .countResultType
        do {
            let count = try viewContext.count(for: request)
            // 根据业务逻辑判断，比如已知iCloud中至少有1条数据时，count>0即认为同步完成
            isSyncCompleted = count > 0
        } catch {
            print("检查数据数量失败：\(error)")
        }
    }
}

注意事项 #

1. 同步时间取决于数据量大小，需始终给用户显示加载状态，避免空白界面
2. 需处理同步失败场景（如网络不可用），可添加重试逻辑或提示用户检查网络
3. 可结合多种方法提升准确性，比如先检查历史事件，再监听实时同步通知

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