Nothing Special   »   [go: up one dir, main page]
Scribd Logo
Upload

Welcome to Scribd!

  • 35 views

    Codable With Core Data and NSManagedObject

    Uploaded by

    vaxesu
    The document discusses how to make NSManagedObject subclasses conform to the Codable protocol to allow Core Data objects to be encoded to and decoded from JSON. It explains that the default code generation will not work, so subclasses must be manually defined. It provides code to define a managed object context key to pass the context through JSON decoding, and examples of initializing managed object subclasses from a decoder while associating them with a managed object context.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    Codable With Core Data and NSManagedObject

    Uploaded by

    vaxesu
    35 views11 pages
    The document discusses how to make NSManagedObject subclasses conform to the Codable protocol to allow Core Data objects to be encoded to and decoded from JSON. It explains that the default code generation will not work, so subclasses must be manually defined. It provides code to define a managed object context key to pass the context through JSON decoding, and examples of initializing managed object subclasses from a decoder while associating them with a managed object context.

    Original Description:

    Original Title

    Codable with Core Data and NSManagedObject

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document discusses how to make NSManagedObject subclasses conform to the Codable protocol to allow Core Data objects to be encoded to and decoded from JSON. It explains that the default code generation will not work, so subclasses must be manually defined. It provides code to define a managed object context key to pass the context through JSON decoding, and examples of initializing managed object subclasses from a decoder while associating them with a managed object context.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    35 views11 pages

    Codable With Core Data and NSManagedObject

    Uploaded by

    vaxesu
    The document discusses how to make NSManagedObject subclasses conform to the Codable protocol to allow Core Data objects to be encoded to and decoded from JSON. It explains that the default code generation will not work, so subclasses must be manually defined. It provides code to define a managed object context key to pass the context through JSON decoding, and examples of initializing managed object subclasses from a decoder while associating them with a managed object context.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 11

    Using Codable with Core Data

    and NSManagedObject
    Published on: August 3, 2020
    CODABLE CORE DATA SWIFT
    If you've ever wanted to decode a bunch of JSON data into
    NSManagedObject instances you've probably noticed that this isn't a
    straightforward exercise. With plain structs, you can conform your
    struct to Codable and you convert the struct from and to JSON data
    automatically.
    <img src="https://www.donnywals.com/wp-content/uploads/
    RevenueCatLogo.png">
    In-app purchases made easy. RevenueCat provides everything you need to
    implement, manage, and analyze in-app purchases without managing servers
    or writing backend code.

    Try RevenueCat now

    This sponsored message helps keep the content on this site free. Please check
    out this sponsor as it directly supports me and this site.

    For an NSManagedObject subclass it's not that easy.

    If your Core Data data model is con gured to automatically


    generate your entity class de nitions for you (which is the default),
    you may have tried to write the following code to conform your
    managed object to Decodable:

    extension MyManagedObject: Decodable { }


    If you do this, the compiler will tell you that it can't synthesize an
    implementation for init(from:) for a class that's de ned in a different
    le. Xcode will offer you some suggestions like adding an initializer,
    marking it as convenience and eventually the errors will point you
    towards making your init required too, resulting in something like the
    following:

    extension MyManagedObject: Decodable {


    required convenience public init(from decoder:
    Decoder) throws {
    }
    }
    Once you've written this you'll nd that Xcode still isn't happy and
    that it presents you with the following error:

    'required' initializer must be declared directly in class


    'MyManagedObject' (not in an extension)

    In this week's post, you will learn how you can manually de ne your
    managed object subclass and add support for Swift's JSON
    fi
    fi
    fi
    fi
    fi
    fi
    decoding and encoding features by conforming your managed
    object to Decodable and Encodable. First, I'll explain how you can
    tweak automatic class generation and de ne your managed object
    subclasses manually while still generating the de nition for all of
    your entity's properties.

    After that, I'll show you how to conform your managed object to
    Decodable, and lastly, we'll add conformance for Encodable as well to
    make your managed object conform to the Codable protocol (which
    is a combined protocol of Decodable and Encodable).

    Tweaking your entity's code generation


    Since we need to de ne our managed object subclass ourselves to
    add support for Codable, you need to make some changes to how
    Xcode generates code for you.

    Open your xcdatamodeld le and select the entity that you want to
    manually de ne the managed object subclass for. In the sidebar on
    the right, activate the Data model inspector and set the Codegen
    dropdown to Category/Extension. Make sure that you set Module to
    Current product module and that Name is set to the name of the
    managed object subclass that you will de ne. Usually, this class
    name mirrors the name of your entity (but it doesn't have to).

    <img src="https://
    www.donnywals.com/wp-content/uploads/Screen-Shot-2020-08-03-
    at-10.09.16.png" alt="" />
    fi
    fi
    fi
    fi
    fi
    fi
    After setting up your data model, you can de ne your subclasses.
    Since Xcode will generate an extension that contains all of the
    managed properties for your entity, you only have to de ne the
    classes that Xcode should extend:

    class TodoItem: NSManagedObject {


    }

    class TodoCompletion: NSManagedObject {


    }
    Once you've de ned your managed object subclasses, Xcode
    generates extensions for these classes that contain all of your
    managed properties while giving you the ability to add the required
    initializers for the Decodable and Encodable protocols.

    Let's add conformance for Decodable rst.

    Conforming an NSManagedObject to
    Decodable
    The Decodable protocol is used to convert JSON data into Swift
    objects. When your objects are relatively simple and closely mirror
    the structure of your JSON, you can conform the object to Decodable
    and the Swift compiler generates all the required decoding code for
    you.

    Unfortunately, Swift can't generate this code for you when you want
    to make your managed object conform to Decodable.

    Because Swift can't generate the required code, we need to de ne


    the init(from:) initializer ourselves. We also need to de ne the
    CodingKeys object that de nes the JSON keys that we want to use
    when decoding JSON data. Adding the initializer and CodingKeys for
    the objects from the previous section looks as follows:

    class TodoCompletion: NSManagedObject, Decodable {


    enum CodingKeys: CodingKey {
    case completionDate
    fi
    fi
    fi
    fi
    fi
    fi
    fi
    }

    required convenience init(from decoder: Decoder)


    throws {
    }
    }

    class TodoItem: NSManagedObject, Decodable {


    enum CodingKeys: CodingKey {
    case id, label, completions
    }

    required convenience init(from decoder: Decoder)


    throws {
    }
    }
    Before I get to the decoding part, we need to talk about managed
    objects a little bit more.

    Managed objects are always associated with a managed object


    context. When you want to create an instance of a managed object
    you must pass a managed object context to the initializer.

    When you're initializing your managed object with init(from:) you


    can't pass the managed object context along to the initializer
    directly. And since Xcode will complain if you don't call self.init from
    within your convenience initializer, we need a way to make a
    managed object context available within init(from:) so we can
    properly initialize the managed object.

    This can be achieved through JSONDecoder's userInfo dictionary. I'll


    show you how to do this rst, and then I'll show you what this
    means for the initializer of TodoItem from the code snippet I just
    showed you. After that, I will show you what TodoCompletion ends up
    looking like.
    fi
    Since all keys in JSONDecoder's userInfo must be of type
    CodingUserInfoKey we need to extend CodingUserInfoKey rst to
    create a managed object context key:

    extension CodingUserInfoKey {
    static let managedObjectContext =
    CodingUserInfoKey(rawValue:
    "managedObjectContext")!
    }
    We can use this key to set and get a managed object context from
    the userInfo dictionary. Now let's create a JSONDecoder and set its
    userInfo dictionary:

    let decoder = JSONDecoder()


    decoder.userInfo[CodingUserInfoKey.managedObjectCo
    ntext] = myPersistentContainer.viewContext
    When we use this instance of JSONDecoder to decode data, the
    userInfo dictionary is available within the initializer of the object we're
    decoding to. Let's see how this works:

    enum DecoderConfigurationError: Error {


    case missingManagedObjectContext
    }

    class TodoItem: NSManagedObject, Decodable {


    enum CodingKeys: CodingKey {
    case id, label, completions
    }

    required convenience init(from decoder: Decoder)


    throws {
    guard let context =
    decoder.userInfo[CodingUserInfoKey.managedObjectCo
    ntext] as? NSManagedObjectContext else {
    fi
    throw
    DecoderConfigurationError.missingManagedObjectCont
    ext
    }

    self.init(context: context)

    let container = try decoder.container(keyedBy:


    CodingKeys.self)
    self.id = try container.decode(Int64.self,
    forKey: .id)
    self.label = try container.decode(String.self,
    forKey: .label)
    self.completions = try
    container.decode(Set<TodoCompletion>.self, forKey:
    .completions) as NSSet
    }
    }
    In the initializer for TodoItem I try to extract the object at
    CodingUserInfoKey.managedObjectContext from the Decoder's userInfo
    dictionary and I try to cast it to an NSManagedObjectContext. If this
    fails I throw an error that I've de ned myself because we can't
    proceed without a managed object context.

    After that, I call self.init(context: context) to initialize the TodoItem and


    associate it with a managed object context.

    The last step is to decode the object as you normally would by


    grabbing a container that's keyed by CodingKeys.self and decoding
    all relevant properties into the correct types.

    Note that Core Data still uses Objective-C under the hood so you
    might have to cast some Swift types to their Objective-C
    counterparts like I had to with my Set<TodoCompletion>.

    For completion, this is what the full class de nition for


    TodoCompletion would look like:
    fi
    fi
    class TodoCompletion: NSManagedObject, Decodable {
    enum CodingKeys: CodingKey {
    case completionDate
    }

    required convenience init(from decoder: Decoder)


    throws {
    guard let context =
    decoder.userInfo[CodingUserInfoKey.managedObjectCo
    ntext] as? NSManagedObjectContext else {
    throw
    DecoderConfigurationError.missingManagedObjectCont
    ext
    }

    self.init(context: context)

    let container = try decoder.container(keyedBy:


    CodingKeys.self)
    self.completionDate = try
    container.decode(Date.self,
    forKey: .completionDate)
    }
    }
    This code shouldn't look surprising; it's basically the same as the
    code for TodoItem. Note that the decoder that's used to decode the
    TodoItem is also used to decode TodoCompletion which means that it
    also has the managed object context in its userInfo dictionary.

    If you want to test this code, you can use the following JSON as a
    starting point:

    [
    {
    "id": 0,
    "label": "Item 0",
    "completions": []
    },
    {
    "id": 1,
    "label": "Item 1",
    "completions": [
    {
    "completionDate": 767645378
    }
    ]
    }
    ]
    Unfortunately, it takes quite a bunch of code to make Decodable
    work with managed objects, but the nal solution is something I'm
    not too unhappy with. I like how easy it is to use once set up
    properly.

    Adding support for Encodable to an


    NSManagedObject
    While we had to do a bunch of custom work to add support for
    Decodable to our managed objects, adding support for Encodable is
    far less involved. All we need to do is de ne encode(to:) for the
    objects that need Encodable support:

    class TodoItem: NSManagedObject, Codable {


    enum CodingKeys: CodingKey {
    case id, label, completions
    }

    required convenience init(from decoder: Decoder)


    throws {
    // unchanged implementation
    }
    fi
    fi
    func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy:
    CodingKeys.self)
    try container.encode(id, forKey: .id)
    try container.encode(label, forKey: .label)
    try container.encode(completions as!
    Set<TodoCompletion>, forKey: .completions)
    }
    }
    Note that I had to convert completions (which is an NSSet) to a
    Set<TodoCompletion> explicitly. The reason for this is that NSSet isn't
    Encodable but Set<TodoCompletion> is.

    For completion, this is what TodoCompletion looks like with Encodable


    support:

    class TodoCompletion: NSManagedObject, Codable {


    enum CodingKeys: CodingKey {
    case completionDate
    }

    required convenience init(from decoder: Decoder)


    throws {
    // unchanged implementation
    }

    func encode(to encoder: Encoder) throws {


    var container = encoder.container(keyedBy:
    CodingKeys.self)
    try container.encode(completionDate,
    forKey: .completionDate)
    }
    }
    Note that there is nothing special that I had to do to conform my
    managed object to Encodable compared to a normal manual
    Encodable implementation.

    In Summary
    In this week's post, you learned how you can add support for
    Codable to your managed objects by changing Xcode's default code
    generation for Core Data entities, allowing you to write your own
    class de nitions. You also saw how you can associate a managed
    object context with a JSONDecoder through its userInfo dictionary,
    allowing you to decode your managed objects directly from JSON
    without any extra steps. To wrap up, you saw how to add Encodable
    support, making your managed object conform to Codable rather
    than just Decodable.
    fi

    You might also like