Início / coding / Perguntas / 77708533
Accepted
Vincent
Asked: 2023-12-24 01:59:02 +0800 CST

Vinculação SwiftUI com CoreData no formulário

  • 772

Eu tenho um modelo Core Data com múltiplas propriedades e um formulário para editar todas essas propriedades.
Quero que as alterações sejam "salvas automaticamente". Assim, assim que eu alterar algo no formulário, ele será salvo em meu contexto de dados principal.

Eu me pego fazendo muitas ligações personalizadas para salvar meu contexto nas alterações, por exemplo:

TextField("My string", 
  text: Binding(
    get: {
        model.myString
    }, 
    set: { newValue in
        model.myString = newValue
        try? context.save()
    }
  )
)

Gostaria de simplificar meu código e ter uma ligação especial vinculada ao contexto de dados principais para evitar esse padrão. Como eu poderia simplificar isso?

forms

1 respostas

  1. Best Answer

    Se você tem

    @Environment(\.managedObjectContext) var context
@ObservedObject var model: SomeType

    No topo da visualização

    Você pode usar

     .task(id: model.hasChanges) {
      guard model.hasChanges else {return}
      try? context.save()
  }

    Ele será salvo sempre que houver uma alteração.

    Você pode colocar isso ViewModifierpara facilitar o acesso em qualquer lugar onde deseja salvar automaticamente.

    import SwiftUI
import CoreData
struct SimpleItemListView: View {
    @FetchRequest( sortDescriptors: []) var items: FetchedResults<SimpleItem>
    var body: some View {
        List(items) { item in
            Text(item.name ?? "")
                .autoSave(item) // Use like this.
        }
    }
}

#Preview {
    SimpleItemListView()
        .environment(\.managedObjectContext, PersistenceController.preview.container.viewContext)
}

//MARK: AutoSave ViewModifier just copy & paste.

extension View {
    func autoSave<MO>(_ object: MO) -> some View where MO: NSManagedObject  {
        modifier(AutoSave(object: object))
    }
}
struct AutoSave<MO>: ViewModifier where MO: NSManagedObject {
    @Environment(\.managedObjectContext) var managedObjectContext
    @ObservedObject var object: MO
    @State private var alert: (isPresented: Bool, error: LocalError?) = (false, nil)
    func body(content: Content) -> some View {
        content
            .alert(isPresented: $alert.isPresented, error: alert.error, actions: {
                Button("Ok") {
                    alert = (false, nil)
                }
            })
            .task(id: object.hasChanges) {
                guard object.hasChanges else {return}
                do {
                    try await managedObjectContext.perform {
                        try managedObjectContext.save()
                    }
                } catch {
                    alert = (true, LocalError.error(error))
                }
            }
    }
    private enum LocalError: LocalizedError {
        case error(Error)
        
        var errorDescription: String?{
            switch self {
            case .error(let error):
                return error.localizedDescription
            }
        }
    }
}
    • 2

relate perguntas