Core Data+MVVM+SwiftUI架构下，采用单一ViewModel管理所有Core Data实体是否为合理实践？

AI 小北

2026-4-28

Is a Single ViewModel for All Core Data Entities a Good Practice in MVVM+SwiftUI?

Great question—let’s break this down clearly. Using a single ViewModel to manage all your Core Data entities is not a long-term best practice, especially as your app grows. Here’s why, plus a better approach tailored to your entity hierarchy (Car → CarService → ServiceRecord):

Why Your Current Setup Will Cause Pain

Your CarViewModel is already taking on too much responsibility: it’s handling CRUD for three related entities, which will only get worse as you add features (like filtering, validation, or business rules). This violates the Single Responsibility Principle—a core tenant of MVVM—and leads to:

Bloated, hard-to-maintain code (your file size issue is just the first sign)
Tight coupling between entities (changing how ServiceRecord works forces changes to CarViewModel)
Difficult unit testing (you can’t test Car logic in isolation without loading Service/Record code)

The Better Approach: Hierarchical ViewModels

Since your entities have a parent-child relationship, your ViewModels should mirror that structure. Each ViewModel handles exactly one entity type, and depends on its parent entity to scope operations (e.g., only fetch CarServices belonging to a specific Car).

Step 1: Split ViewModels by Entity

Here’s how to refactor your code:

1. CoreDataManager (Keep as-is, but consider dependency injection)

Your singleton works fine for now, but for testing, you might want to pass it via initializers instead of using .instance directly.

2. CarViewModel (Only handles Car entities)

class CarViewModel: ObservableObject{
    let manager: CoreDataManager
    @Published var cars: [Car] = []
    
    init(coreDataManager: CoreDataManager = .instance){
        self.manager = coreDataManager
        fetchCars()
    }
    
    // Car-specific operations only
    func addCar(name: String) {
        let newCar = Car(context: manager.context)
        newCar.name = name
        save()
        fetchCars()
    }
    
    func deleteCar(_ car: Car) {
        manager.context.delete(car)
        save()
        fetchCars()
    }
    
    func updateCar(_ car: Car, newName: String) {
        car.name = newName
        save()
        fetchCars()
    }
    
    private func fetchCars() {
        let request: NSFetchRequest<Car> = Car.fetchRequest()
        do {
            cars = try manager.context.fetch(request)
        } catch {
            print("Fetch cars error: \(error.localizedDescription)")
        }
    }
    
    func save(){
        manager.save()
    }
}

3. CarServiceViewModel (Scoped to a single Car)

class CarServiceViewModel: ObservableObject{
    let manager: CoreDataManager
    let parentCar: Car
    @Published var carServices: [CarService] = []
    
    init(parentCar: Car, coreDataManager: CoreDataManager = .instance){
        self.parentCar = parentCar
        self.manager = coreDataManager
        fetchServicesForCar()
    }
    
    // Service-specific operations, tied to the parent Car
    func addService(name: String, cost: Double) {
        let newService = CarService(context: manager.context)
        newService.name = name
        newService.cost = cost
        newService.car = parentCar // Link to parent entity
        save()
        fetchServicesForCar()
    }
    
    func deleteService(_ service: CarService) {
        manager.context.delete(service)
        save()
        fetchServicesForCar()
    }
    
    private func fetchServicesForCar() {
        let request: NSFetchRequest<CarService> = CarService.fetchRequest()
        request.predicate = NSPredicate(format: "car == %@", parentCar)
        do {
            carServices = try manager.context.fetch(request)
        } catch {
            print("Fetch services error: \(error.localizedDescription)")
        }
    }
    
    func save(){
        manager.save()
    }
}

4. ServiceRecordViewModel (Scoped to a single CarService)

class ServiceRecordViewModel: ObservableObject{
    let manager: CoreDataManager
    let parentService: CarService
    @Published var serviceRecords: [ServiceRecord] = []
    
    init(parentService: CarService, coreDataManager: CoreDataManager = .instance){
        self.parentService = parentService
        self.manager = coreDataManager
        fetchRecordsForService()
    }
    
    func addRecord(name: String, cost: Double) {
        let newRecord = ServiceRecord(context: manager.context)
        newRecord.name = name
        newRecord.cost = cost
        newRecord.service = parentService // Link to parent entity
        save()
        fetchRecordsForService()
    }
    
    func deleteRecord(_ record: ServiceRecord) {
        manager.context.delete(record)
        save()
        fetchRecordsForService()
    }
    
    private func fetchRecordsForService() {
        let request: NSFetchRequest<ServiceRecord> = ServiceRecord.fetchRequest()
        request.predicate = NSPredicate(format: "service == %@", parentService)
        do {
            serviceRecords = try manager.context.fetch(request)
        } catch {
            print("Fetch records error: \(error.localizedDescription)")
        }
    }
    
    func save(){
        manager.save()
    }
}

Step 2: Pass ViewModels Between SwiftUI Views

Instead of passing a single CarViewModel everywhere, you’ll create child ViewModels when navigating to child views, using the parent entity as context:

CarsView (Root View)

struct CarsView: View {
    @StateObject private var carViewModel = CarViewModel()
    
    var body: some View {
        NavigationStack {
            VStack {
                Button("Add New Car") {
                    carViewModel.addCar(name: "New Car \(Date())")
                }
                
                List {
                    ForEach(carViewModel.cars) { car in
                        // Navigate to ServicesView, passing the selected Car
                        NavigationLink(destination: ServicesView(parentCar: car)) {
                            Text(car.name ?? "Unnamed Car")
                        }
                    }
                    .onDelete(perform: deleteCar)
                }
            }
            .navigationTitle("My Cars")
        }
    }
    
    private func deleteCar(at offsets: IndexSet) {
        guard let index = offsets.first else { return }
        let car = carViewModel.cars[index]
        carViewModel.deleteCar(car)
    }
}

ServicesView

struct ServicesView: View {
    let parentCar: Car
    @StateObject private var serviceViewModel: CarServiceViewModel
    
    // Initialize the ViewModel with the parent Car
    init(parentCar: Car) {
        self.parentCar = parentCar
        self._serviceViewModel = StateObject(wrappedValue: CarServiceViewModel(parentCar: parentCar))
    }
    
    var body: some View {
        NavigationStack {
            VStack {
                Button("Add Service") {
                    serviceViewModel.addService(name: "New Service", cost: 0.0)
                }
                
                List {
                    ForEach(serviceViewModel.carServices) { service in
                        NavigationLink(destination: RecordsView(parentService: service)) {
                            Text(service.name ?? "Unnamed Service")
                        }
                    }
                    .onDelete(perform: deleteService)
                }
            }
            .navigationTitle("\(parentCar.name ?? "Car") Services")
        }
    }
    
    private func deleteService(at offsets: IndexSet) {
        guard let index = offsets.first else { return }
        let service = serviceViewModel.carServices[index]
        serviceViewModel.deleteService(service)
    }
}

RecordsView

struct RecordsView: View {
    let parentService: CarService
    @StateObject private var recordViewModel: ServiceRecordViewModel
    
    init(parentService: CarService) {
        self.parentService = parentService
        self._recordViewModel = StateObject(wrappedValue: ServiceRecordViewModel(parentService: parentService))
    }
    
    var body: some View {
        NavigationStack {
            VStack {
                Button("Add Record") {
                    recordViewModel.addRecord(name: "New Record", cost: 0.0)
                }
                
                List {
                    ForEach(recordViewModel.serviceRecords) { record in
                        Text(record.name ?? "Unnamed Record")
                    }
                    .onDelete(perform: deleteRecord)
                }
            }
            .navigationTitle("\(parentService.name ?? "Service") Records")
        }
    }
    
    private func deleteRecord(at offsets: IndexSet) {
        guard let index = offsets.first else { return }
        let record = recordViewModel.serviceRecords[index]
        recordViewModel.deleteRecord(record)
    }
}

Bonus Tips for Improvement

Use @FetchRequest for simpler data fetching: For basic lists, you can skip the ViewModel’s fetch method and use SwiftUI’s built-in @FetchRequest directly in views. Reserve ViewModels for complex logic (like validation or dynamic filtering).
Dependency injection: Instead of relying on the CoreDataManager singleton, pass it into ViewModels via initializers. This makes unit testing easier (you can mock the manager).
Avoid exposing NSManagedObjectContext to views: Keep all Core Data operations wrapped in ViewModels so views only handle UI logic.

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