Aqui você pode ver o artigo original

Recentemente, tive que criar um aplicativo usando SwiftUI e CoreData .

Achei que o CoreData fosse usado quase como você usaria com o UIKit, mas aparentemente há algumas diferenças.

Este guia pretende ser um resumo da minha experiência usando CoreData combinado com SwiftUI. Se eu encontrar outros aspectos, irei adicioná-los a este guia.

Então, sem mais delongas, vamos começar.

Configurar

Esta é uma parte bastante simples.

• Se você iniciar um novo projeto, poderá marcar a opção ' Usar dados principais ' e ' Hospedar no CloudKit ' se quiser salvar os dados de seus usuários na nuvem. Nesse caso, o XCode cuidará da configuração do projeto para você. (Para a parte do CloudKit serão necessários alguns passos extras).
• Se você já tem um projeto, precisará criar um arquivo Persistence.swift e um arquivo swift onde inicializar a pilha CoreData. (Você pode até mesmo criar um novo projeto seguindo o passo anterior, e copiar o arquivo Persistence.swift gerado pelo XCode para o seu projeto.

Agora que você tem seu projeto, para poder usar CoreData dentro de suas Views, você precisa passar a managedObjectContexthierarquia de suas views para baixo.

Normalmente, isso é feito no arquivo [appname]App.swift .

PersistenceController ( aqui está um exemplo ) é a estrutura que o XCode gera automaticamente para você quando você inicia um novo projeto com a opção 'Usar Core Data' marcada.

@main
struct ExampleApp: App {

  let persistenceController = PersistenceController.shared

  var body: some Scene {
    WindowGroup {
      ContentView()
        .environmentObject(persistenceController)
        .environment(\.managedObjectContext, persistenceController.container.viewContext)
    }
  }
}

Ótimo, agora você pode criar, ler, atualizar e excluir NSManagedObjects em suas visualizações.

Operando com CoreData

Para operar com CoreData você precisa acessar o NSManagedObjectContext. Para fazer isso, você tem duas opções:

• Usando o wrapper @ Environment em suas visualizações

@Environment(\.managedObjectContext) private var viewContext

@EnvironmentObject private var persistenceController: PersistenceController

do {
  if container.viewContext.hasChanges {
    try container.viewContext.save()
  }
} catch {
  print(error)
}

Para salvar um NSManagedObject você primeiro precisa instanciá-lo e depois configurar suas propriedades. E então salve o contexto.

let note = Note(context: container.viewContext)
note.id = id
note.text = text
note.folder = folder
note.creationDate = Date()
saveContext()

Buscando objetos

Agora a parte de buscar, foi aqui que encontrei mais dificuldades. Vamos começar imediatamente.

Para buscar objetos no SwiftUI, a maneira mais conveniente de fazer isso é usar os wrappers @FetchRequest ou @SectionedFetchRequest , em cada View que você precisa ler do CoreData.

Passar objetos buscados entre Views interromperá as atualizações automáticas caso você adicione, edite ou exclua objetos. (Se você souber uma maneira de passar a busca de objetos sem interromper as atualizações, avise-me e atualizarei este guia)

Portanto, você precisa adicionar um @FetchRequest em todas as visualizações de objetos CoreData e atualizações automáticas. Eu sei que é um pouco chato, mas vai valer a pena.

Então, dito isso, o código é o seguinte:

@FetchRequest(entity: \Object.type,
              sortDescriptors: [NSSortDescriptor],
              predicate: NSPredicate,
              animation: .default)
var objects: [Object]

@SectionedFetchRequest(entity: \Object.type,
                         sectionIdentifier: \Object.property,
                         sortDescriptors: [NSSortDescriptor],
                         predicate: NSPredicate,
                         animation: .default)
var sections: SectionedFetchResults<YourSectionType, Object>

List(sections) { section in
  Section(section.id) {
    ForEach(section) { object in
      // Configure your view with the object
    }
  }
}

Usando @FetchRequest ou @SectionedFetchRequest onde quer que você adicione, atualize ou exclua um objeto, as visualizações são atualizadas automaticamente.

Agora, se você precisar usar um @FetchRequest com um NSPredicate que tenha um parâmetro passado da View pai, descobri que a próxima opção funciona maravilhosamente bem.

@FetchRequest
var objects: FetchedResults<Object>

init(id: ID) {
  _objects = FetchRequest<Object>(predicate: NSPredicate(format: "id == %@", id))
}

Atualizando objetos

Para atualizar um NSManagedObjectvocê precisará ter o NSManagedObjectto update, obtido conforme descrito anteriormente e atualizar suas propriedades. E então salve o contexto.

note.text = newText
note.folder = newFolder
saveContext()

Para excluir um, NSManagedObjectvocê precisará atualizar NSManagedObject, buscar conforme descrito anteriormente e excluí-lo.

viewContext.delete(object)

Conclusão

Isso é tudo que descobri até agora sobre CoreData usado com SwiftUI. Este guia será constantemente atualizado.

Se você quiser sugerir uma maneira melhor de fazer algo, deixe um comentário e atualizarei este guia com a melhor opção.

Espero ter ajudado você em sua jornada com desenvolvimento SwiftUI e iOS.

DEIXE UM CLAP se você gostou deste artigo, eu realmente aprecio isso.

Nos vemos no próximo guia!

Se você gostaria de apoiar meu trabalho e ver este guia em ação, confira BrainDump — Notes & Writing .

Obrigado