Hey, I am new to SwiftUI (2.0) and I'm trying to follow the MVVM pattern. While trying to implement CoreData, I ran into some issues. While I can access my data from the View, I can't find out how I would access it from my ViewModel. Can give me a tip how to make the implementation of CoreData conform to MVVM?

MyApp.swift:

import SwiftUI
import CoreData

@main
struct MyApp: App {

    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            MainView()
                .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: "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)")
                }
            }
        }
}

MainView.swift:

struct MainView: View {
     @FetchRequest(
    entity: MyModel.entity(),
    sortDescriptors: [ ]
  ) var model: FetchedResults<MyModel>
  @Environment(\.managedObjectContext) var managedObjectContext

    /// Code
}

hi,

Core Data stores Entities that have Attributes (which include relationships among the Entities). the PersistentContainer that you access on disk/cloud that holds the Core Data store happens to be named "Model."

as far as i understand the MVVM design in the presence of Core Data, all of Core Data is basically your Model. when you set up a @FetchRequest in a View, that provides access to some/all entities in Core Data of a certain type, and so is a window into your Model, and thus it can often function as the ViewModel inside the View, since its role in life is to keep the View updated when the Core Data objects in the model behind the fetch request change.

in your code, you appear to have an Entity named "MyModel" and so the @FetchRequest variable var model is then (essentially) a list of all the entities in Core Data with entity type MyModel. it is not a single thing like "my whole model" as the variable name suggests. depending on how you use the model variable, its type will be (essentially) [MyModel]. (it's really FetchedResults<MyModel>, but most code you write will look as if its type were [MyModel].)

so i'd suggest that a little renaming might be of help here (too many things are called something like "model"). and what attributes constitute a "MyModel" entity? when we see the MyModel definition (and any other Core Data entities you have or intend to have), we can probably say more.

hope that helps,

DMG

Hi @delawaremathguy

Thanks for your quick answer! Currently I'm using UserDefaults to save my model, but I want to transition this to using CoreData. My CoreData entity is base on the following model:

struct Account: Identifiable {
    var name: String
    var balance: Float
    var primaryColor: Color
    var secondaryColor: Color
    let id: UUID = UUID()

    init(name: String, balance: Float, primaryColor: Color, secondaryColor: Color) {
        self.name = name
        self.balance = balance
        self.primaryColor = primaryColor
        self.secondaryColor = secondaryColor
    }
}

This model is then linked to the view with the following viewmodel:

class AccountStore: ObservableObject {
    @Published var accounts = [Account]()

    var totalBalance: Float
        var totalBalance: Float = 0
        for account in accounts {
            totalBalance += account.balance
        }
        return totalBalance
    }

    init(accounts: [Account]) {
        self.accounts = accounts
    }

}

The viewmodel has a variable where all instances of my model are stored and a computed property that has to access these instances of my model, since I don't want to make these calculation in the view. I'm not sure how I would implement this computed variable else. Therefore I wanted to first load the instances from coredata into a viewmodel.

L4M

Thanks again! This post helped me understand the topic alot better. I will try to implement it as soon as I can. For saving colors I found a solution using UIColor and converting it to NSData for storage.

Have a nice day :) L4M