如何在Core Data后台更新后自动刷新SwiftUI视图（无需调用onAppear）

Great question! This is a super common gotcha with SwiftUI + Core Data, and it almost always ties back to how Core Data contexts are managed or how SwiftUI observes changes. Here are three solid fixes you can try:

1. Enable Automatic Context Merging (Best Practice) #

First, make sure your main Core Data context is set to automatically merge changes from background contexts. If you're using a background context to save network-synced data (which you absolutely should, to avoid blocking the main thread), this tells the main context to pick up those changes immediately.

Add this line when setting up your PersistentContainer (usually in your app's Core Data manager or root App struct):

persistentContainer.viewContext.automaticallyMergesChangesFromParent = true

This should make your @FetchRequest in Page1 detect the new data automatically when you return from Page2—no extra view code needed.

2. Explicitly Trigger a Refresh on Dismiss #

If you want more direct control, you can pass a completion handler to Page2 that tells Page1 to refresh when you return.

First, update Page2 to accept a dismiss callback:

struct Page2: View {
    let onDismiss: () -> Void
    // Your existing Core Data properties here

    var body: some View {
        VStack {
            // Your Page2 UI content
            Button("Save & Return") {
                // Perform your Core Data save operations here
                try? persistentContainer.viewContext.save()
                
                // Trigger the refresh before dismissing
                onDismiss()
                // If using a navigation stack, pop the view here (e.g., with @Environment(\.dismiss))
            }
        }
    }
}

Then modify Page1 to pass the refresh action and add a dummy state to force the view to reload:

struct Page1: View { 
    @FetchRequest(entity: Word.entity(), sortDescriptors: []) var wordsFromCoreData: FetchedResults<Word> 
    @State var isPresenting = false
    @State private var refreshToggle = false

    var body: some View { 
        NavigationView{
            VStack{
                NavigationLink(destination: Page2(onDismiss: {
                    refreshToggle.toggle()
                })){
                    Text("Add") 
                } 
                List(wordsFromCoreData, id: \.self){item in 
                    WordRowView(word:item) 
                }
                .navigationBarTitle(Text("English Words"))
                .id(refreshToggle) // This forces the list to redraw when toggle changes
            } 
        } 
    } 
}

The .id(refreshToggle) modifier makes SwiftUI treat the list as a new view whenever the toggle changes, which triggers a fresh fetch from Core Data.

3. Wrap Fetch Logic in an Observable Object #

For more complex scenarios (like adding filtering or sorting), you can move your fetch logic into an ObservableObject that you can explicitly refresh:

class WordDataManager: ObservableObject {
    @Published var words: [Word] = []
    private let context = PersistenceController.shared.container.viewContext

    init() {
        fetchWords()
    }

    func fetchWords() {
        do {
            words = try context.fetch(Word.fetchRequest())
        } catch {
            print("Error fetching words: \(error.localizedDescription)")
        }
    }
}

Then use it in Page1:

struct Page1: View { 
    @StateObject private var dataManager = WordDataManager()
    @State var isPresenting = false

    var body: some View { 
        NavigationView{
            VStack{
                NavigationLink(destination: Page2(onDismiss: {
                    dataManager.fetchWords()
                })){
                    Text("Add") 
                } 
                List(dataManager.words, id: \.self){item in 
                    WordRowView(word:item) 
                }
                .navigationBarTitle(Text("English Words"))
            } 
        } 
    } 
}

This gives you full control over when data is fetched, and the @Published property will automatically update the view when the words array changes.

Which Fix to Pick? #

• Option 1 is the most seamless—it's the "correct" Core Data way to handle cross-context updates, and it works without modifying your view flow.
• Option 2 is a quick, lightweight fix if you just need a one-off refresh.
• Option 3 is ideal if you need to add more logic to your fetch operations.

Start with Option 1—it should resolve the issue with minimal changes to your existing code!

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