Using Core Data with SwiftUI App Protocol

Code Block swift
@main
struct SampleApp: App {
    @Environment(\.scenePhase) private var scenePhase
    var body: some Scene {
        WindowGroup {
            MovieList()
                .environment(\.managedObjectContext, persistentContainer.viewContext)
        }
        .onChange(of: scenePhase) { phase in
            switch phase {
            case .active:
                print("active")
            case .inactive:
                print("inactive")
            case .background:
                print("background")
                saveContext()
            }
        }
    }
    var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "SampleApp")
        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)")
            }
        }
    }
}

Code Block 
    var persistentContainer: NSPersistentContainer = {        
				let container = NSPersistentCloudKitContainer(name: "SampleApp")     						 // change this line 
        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {                
								fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
				container.viewContext.automaticallyMergesChangesFromParent = true								 // add this line
        return container
    }()

Code Block 
@Environment(\.managedObjectContext) var moc

Code Block 
final class PersistentStore {
		
		let shared = PersistentStore()
		lazy var persistentStore = { ... }
		func saveContext() { ... }
}

Code Block 
var body: some Scene {        
		WindowGroup {            
				MovieList()
						.environment(\.managedObjectContext, PersistentStore.shared)
		}
}

Code Block 
final class PersistentStore: ObservableObject {
		@Published var patient: Patient
		init(patientUUID: UUID) {
				/* Fetch request, get the patient with that UUID, etc
				... */
		}
		func changePatient(to: UUID) {
		}
}

Code Block 
var cancellableBag = Set<AnyCancellable>()
override func viewDidLoad {
		PersistentStore.shared.patient.objectWillChange.sink { _in 
				reloadView() /* Or other implementations of what you want to do */
		}.store(in: &cancellableBag)
}

Code Block 
MainView().environment(\.managedObjectContext, PersistentStore.shared)

Code Block 
import Foundation
import CoreData
final class PersistentStore: ObservableObject {
    @Published var accounts = [Account]()
    static let shared = PersistentStore()
    private init() {
        fetchEntries()
    }
    func fetchEntries() {
            let moc = persistentContainer.viewContext
            let request: NSFetchRequest<Account> = Account.fetchRequest()
            do {
                let accountsCoreData = try moc.fetch(request)
                accounts = accountsCoreData
            } catch {
                print("Fetch failed: Error \(error.localizedDescription)")
                accounts = []
            }
        }
    var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "Model")
        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)")
            }
        }
    }
}

Code Block 
var body: some Scene {
        		WindowGroup {
            				MovieList()
						.environment(\.managedObjectContext, PersistentStore.shared)
		}
}

Code Block swift
var context: NSManagedObjectContext {
		return persistentContainer.viewContext
}

Code Block swift
var body: some Scene {        		
		 WindowGroup {            				
					MovieList()						
							 .environment(\.managedObjectContext, PersistentStore.shared.context)	
					}
}

Code Block 
MainView().environment(\.managedObjectContext, PersistentStore.shared.persistentContainer.viewContext)

Code Block 
MainView().environment(\.managedObjectContext, PersistentStore.shared.persistentContainer.viewContext)

1. Pass the context through the \.managedObjectContext environment key, and recreate all the save, creating, fetching functions wherever you read the context [Obviously this would be a silly approach, with a lot of duplicated code prone to errors]

2. Create a helper class that contains all the save, creating, fetching functions, and pass that into the environment, while separately passing around the viewContext as described above. [This works, but it would be better to pass the context and the helper functions together].

3. Pass the store instance into the environment as an environmentObject, but not using the \.managedObjectContext key [This seems like it should work, but the app kept crashing when it tried to read the fetched objects from the store - most likely I was doing something wrong.]

4. Something like what AlbertUI proposed, but with some (currently unknown?) tweak to address the problem that the \.managedObjectContext key requires an NSManagedObjectContext object instead of a store singleton.

There is an error at line: .environment(\.managedObjectContext, persistentContainer.viewContext) Error: "Cannot use mutating getter on immutable value: 'self' is immutable"

Did you use lazy var persistentContainer? If so, then making it non-lazy should work.

Code Block swift
class PersistentStore {
		static let shared = PersistentStore()
		let persistentContainer: NSPersistentContainer
		private init() {
				self.persistentContainer = // ... 
		}
}