Comment utiliser swift 4 Codable dans Core Data ?

Question

Codable semble être une fonctionnalité très intéressante. Mais je me demande comment nous pouvons l'utiliser dans Core Data ? En particulier, est-il possible d'encoder/décoder directement un JSON depuis/vers un NSManagedObject ?

J'ai essayé un exemple très simple :

et défini Foo moi-même :

import CoreData

@objc(Foo)
public class Foo: NSManagedObject, Codable {}

Mais en l'utilisant comme ça :

let json = """
{
    "name": "foo",
    "bars": [{
        "name": "bar1",
    }], [{
        "name": "bar2"
    }]
}
""".data(using: .utf8)!
let decoder = JSONDecoder()
let foo = try! decoder.decode(Foo.self, from: json)
print(foo)

Le compilateur a échoué avec cette erreur :

super.init isn't called on all paths before returning from initializer

et le fichier cible était le fichier qui définissait Foo

J'ai probablement mal fait les choses, puisque je n'ai même pas passé une NSManagedObjectContext mais je ne sais pas où le mettre.

Les données de base permettent-elles Codable ?

Answer 1

Vous pouvez utiliser le Codable interface avec CoreData objets d'encoder et de décoder des données, cependant il n'est pas aussi automatique que lorsqu'il est utilisé avec un bon vieux swift objets. Voici comment vous pouvez mettre en œuvre Décodage JSON directement avec la Base de Données des objets:

Tout d'abord, vous rendre votre objet de mettre en œuvre Codable. Cette interface doit être défini sur l'objet, et non pas dans une extension. Vous pouvez également définir vos Clés de Codage dans cette classe.

class MyManagedObject: NSManagedObject, Codable {
    @NSManaged var property: String?

    enum CodingKeys: String, CodingKey {
       case property = "json_key"
    }
}

Ensuite, vous pouvez définir la méthode init. Cela doit également être définie dans la méthode de la classe parce que la méthode init est requis par la Décodable protocole.

required convenience init(from decoder: Decoder) throws {
}

Cependant, l'initialiseur correct pour une utilisation avec des objets gérés est:

NSManagedObject.init(entity: NSEntityDescription, into context: NSManagedObjectContext)

Donc, le secret ici est d'utiliser le userInfo dictionnaire de passer dans le contexte de l'objet dans l'initialiseur. Pour ce faire, vous aurez besoin d'étendre l' CodingUserInfoKey struct avec une nouvelle clé:

extension CodingUserInfoKey {
   static let context = CodingUserInfoKey(rawValue: "context")
}

Maintenant, vous pouvez juste que le décodeur pour le contexte:

required convenience init(from decoder: Decoder) throws {

    guard let context = decoder.userInfo[CodingUserInfoKey.context!] as? NSManagedObjectContext else { fatalError() }
    guard let entity = NSEntityDescription.entity(forEntityName: "MyManagedObject", in: context) else { fatalError() }

    self.init(entity: entity, in: context)

    let container = decoder.container(keyedBy: CodingKeys.self)
    self.property = container.decodeIfPresent(String.self, forKey: .property)
}

Maintenant, lorsque vous configurez le décodage des Objets Gérés, vous aurez besoin de passer le long du contexte de l'objet:

let data = //raw json data in Data object
let context = persistentContainer.newBackgroundContext()
let decoder = JSONDecoder()
decoder.userInfo[.context] = context

_ = try decoder.decode(MyManagedObject.self, from: data) //we'll get the value from another context using a fetch request later...

try context.save() //make sure to save your data once decoding is complete

Pour encoder les données, vous aurez besoin de faire quelque chose de similaire à l'aide de l' encoder protocole de fonction.

Answer 2

CoreData est son propre cadre de persistance et, selon sa documentation détaillée, vous devez utiliser ses initialisateurs désignés et suivre un chemin plutôt spécifique pour créer et stocker des objets avec lui.

Vous pouvez toujours utiliser Codable avec elle de manière limitée, tout comme vous pouvez utiliser NSCoding Cependant.

Une façon de procéder est de décoder un objet (ou une structure) avec l'un ou l'autre de ces protocoles et de transférer ses propriétés dans un nouvel objet de type NSManagedObject que vous avez créée selon les documents de Core Data.

Une autre méthode (très courante) consiste à utiliser l'un des protocoles uniquement pour un objet non standard que vous souhaitez stocker dans les propriétés d'un objet géré. Par "non standard", j'entends tout ce qui n'est pas conforme aux types d'attributs standard de Core Data tels que spécifiés dans votre modèle. Par exemple, NSColor ne peut pas être stocké directement en tant que propriété d'un Managed Object car il ne fait pas partie des types d'attributs de base pris en charge par le CD. À la place, vous pouvez utiliser NSKeyedArchiver pour sérialiser la couleur dans un NSData et la stocker comme une propriété Data dans l'objet géré. Inversez ce processus avec NSKeyedUnarchiver . C'est simpliste et il existe une bien meilleure façon de le faire avec Core Data (voir Attributs transitoires ) mais cela illustre mon propos.

Vous pouvez également envisager d'adopter Encodable (l'un des deux protocoles qui composent Codable - pouvez-vous deviner le nom de l'autre ?) pour convertir une instance de Managed Object directement en JSON afin de la partager, mais vous devez spécifier les clés de codage et vos propres encode puisqu'elle ne sera pas auto-synthétisée par le compilateur avec des clés de codage personnalisées. Dans ce cas, il faut spécifier uniquement les clés (propriétés) que vous voulez inclure.

J'espère que cela vous aidera.

Answer 3

Swift 4.2 :

Suivant la solution de Casademora,

guard let context = decoder.userInfo[.context] as? NSManagedObjectContext else { fatalError() }

devrait être

guard let context = decoder.userInfo[CodingUserInfoKey.context!] as? NSManagedObjectContext else { fatalError() } .

Cela évite les erreurs que Xcode reconnaît faussement comme des problèmes de découpage de tableau.

Edit : Utiliser des optionnels implicitement déballés pour supprimer le besoin de forcer le déballage. .context à chaque fois qu'il est utilisé.

Answer 4

Une alternative pour ceux qui souhaitent utiliser l'approche moderne de XCode en matière de gestion de l'environnement. NSManagedObject j'ai créé un fichier DecoderWrapper pour exposer une classe Decoder que j'utilise ensuite à l'intérieur de mon objet qui se conforme à un JSONDecoding protocole :

class DecoderWrapper: Decodable {

    let decoder:Decoder

    required init(from decoder:Decoder) throws {

        self.decoder = decoder
    }
}

protocol JSONDecoding {
     func decodeWith(_ decoder: Decoder) throws
}

extension JSONDecoding where Self:NSManagedObject {

    func decode(json:[String:Any]) throws {

        let data = try JSONSerialization.data(withJSONObject: json, options: [])
        let wrapper = try JSONDecoder().decode(DecoderWrapper.self, from: data)
        try decodeWith(wrapper.decoder)
    }
}

extension MyCoreDataClass: JSONDecoding {

    enum CodingKeys: String, CodingKey {
        case name // For example
    }

    func decodeWith(_ decoder: Decoder) throws {

        let container = try decoder.container(keyedBy: CodingKeys.self)

        self.name = try container.decode(String.self, forKey: .name)
    }
}

Ceci n'est probablement utile que pour les modèles sans attributs non-optionnels, mais cela résout mon problème de vouloir utiliser Decodable mais aussi gérer les relations et la persistance avec Core Data sans avoir à créer manuellement toutes mes classes / propriétés.

Editar: Exemple d'utilisation

Si j'ai un objet json :

let myjson = [ "name" : "Something" ]

Je crée l'objet dans Core Data (force cast ici pour la brièveté) :

let myObject = NSEntityDescription.insertNewObject(forEntityName: "MyCoreDataClass", into: myContext) as! MyCoreDataClass

Et j'utilise l'extension pour que l'objet décode le json :

do {
    try myObject.decode(json: myjson)
}
catch {
    // handle any error
}

Maintenant myObject.name es "Something"