Ici vous pouvez voir l'article original

Récemment, j'ai dû créer une application en utilisant SwiftUI et CoreData .

Je pensais que CoreData était utilisé presque comme vous l'utiliseriez avec UIKit, mais apparemment, il y a quelques différences.

Ce guide se veut un résumé de mon expérience d'utilisation de CoreData combinée à SwiftUI. Si je trouve d'autres aspects, je les ajouterai à ce guide.

Alors, sans plus tarder, commençons.

Installation

C'est une partie assez simple.

• Si vous démarrez un nouveau projet, vous pouvez cocher l'option " Utiliser les données de base " et " Héberger dans CloudKit " si vous souhaitez enregistrer les données de vos utilisateurs dans le cloud. Dans ce cas, XCode se chargera de mettre en place le projet pour vous. (Pour la partie CloudKit, il faudra faire quelques étapes supplémentaires).
• Si vous avez déjà un projet, vous devrez créer un fichier Persistence.swift et un fichier Swift où vous initialisez la pile CoreData. (Vous pouvez même créer un nouveau projet en suivant l'étape précédente et copier le fichier Persistence.swift généré par XCode dans votre projet.

Maintenant que vous avez votre projet, pour pouvoir utiliser CoreData dans vos vues, vous devez transmettre la managedObjectContexthiérarchie de vos vues.

Cela se fait généralement dans votre fichier [appname]App.swift .

PersistenceController ( voici un exemple ) est la structure que XCode génère automatiquement pour vous lorsque vous démarrez un nouveau projet avec l'option "Utiliser les données de base" cochée.

@main
struct ExampleApp: App {

  let persistenceController = PersistenceController.shared

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

Génial, vous pouvez maintenant créer, lire, mettre à jour et supprimer des NSManagedObjects dans vos vues.

Fonctionnement avec CoreData

Pour fonctionner avec CoreData, vous devez accéder au NSManagedObjectContext. Pour ce faire, vous avez deux options :

• Utiliser le wrapper @ Environment dans vos vues

@Environment(\.managedObjectContext) private var viewContext

@EnvironmentObject private var persistenceController: PersistenceController

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

Pour enregistrer un NSManagedObject, vous devez d'abord l'instancier puis configurer ses propriétés. Et puis enregistrez le contexte.

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

Récupérer des objets

Maintenant, la partie aller chercher, c'est là que j'ai rencontré le plus de difficultés. Commençons tout de suite.

Pour récupérer des objets dans SwiftUI, la manière la plus pratique de le faire est d'utiliser les wrappers @FetchRequest ou @SectionedFetchRequest , dans chaque vue que vous devez lire à partir de CoreData.

Le passage d'objets récupérés entre les vues interrompra les mises à jour automatiques au cas où vous ajouteriez, modifieriez ou supprimeriez des objets. (Si vous connaissez un moyen de récupérer des objets sans interrompre les mises à jour, faites-le moi savoir et je mettrai à jour ce guide)

Vous devez donc ajouter un @FetchRequest dans chaque vue dont vous avez besoin d'objets CoreData et de mises à jour automatiques. Je sais que c'est un peu ennuyeux mais ça en vaudra la peine.

Donc, cela dit, le code est le suivant:

@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
    }
  }
}

En utilisant @FetchRequest ou @SectionedFetchRequest partout où vous ajoutez, mettez à jour ou supprimez un objet, les vues sont automatiquement mises à jour.

Maintenant, si vous avez besoin d'utiliser un @FetchRequest avec un NSPredicate qui a un paramètre passé de la vue parente, j'ai trouvé que l'option suivante fonctionne à merveille.

@FetchRequest
var objects: FetchedResults<Object>

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

Mise à jour des objets

Pour mettre à jour un, NSManagedObjectvous devez avoir le NSManagedObjectà mettre à jour, récupéré comme décrit précédemment et mettre à jour ses propriétés. Et puis enregistrez le contexte.

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

Pour supprimer un, NSManagedObjectvous devez avoir le NSManagedObjectà mettre à jour, récupéré comme décrit précédemment et le supprimer.

viewContext.delete(object)

Conclusion

C'est tout ce que j'ai découvert jusqu'à présent sur CoreData utilisé avec SwiftUI. Ce guide sera constamment mis à jour.

Si vous souhaitez suggérer une meilleure façon de faire quelque chose, laissez un commentaire et je mettrai à jour ce guide avec la meilleure option.

J'espère que je vous ai aidé dans votre voyage avec le développement SwiftUI et iOS.

LAISSER UN CLAP si vous avez aimé cet article, je l'apprécie vraiment.

Rendez-vous dans le prochain guide !

Si vous souhaitez soutenir mon travail et voir ce guide en action, consultez BrainDump — Notes & Writing .

Merci