Core Data Stack: Core Data Tutorial (3)

Core Data Stack: Core Data Tutorial

In deze Core Data tutorial bouwen we een app waarin de belangrijkste onderdelen van Core Data aan bod komen. Deze aflevering besteden we aandacht aan de Core Data Stack.

Deel 1 uit deze tutorial vind je hier.

In het vorige artikel uit deze Tutorial hebben we het datamodel, de object graph, van onze app gemaakt. Het datamodel heeft één entiteit, Notitie, met twee attributen, titel en datum.

In één dag Core Data leren?

Met de video-opnames van deze nieuwe LIVE Clinic over Core Data leer je in één dag hoe je zelf Core Data in je apps kunt gebruiken. Gewoon thuis, vanachter je Mac!

Meer informatie

Elke Core Data-entiteit is in feite een class, om precies te zijn een subclass van NSManagedObject. We hebben er nu dus een Notitie-class bijgekregen, met twee properties: .titel en .datum.

Omdat we in de eerste aflevering van deze serie al Notitie-class hebben gemaakt, een ‘prototype’-class, hebben we nu een probleem: er zijn twee Notitie-classes. Dat probleem kunnen we snel oplossen.

Stap 1: we verwijderen onze ‘prototype’-class

We hebben de door ons gemaakte Notitie-class niet langer nodig: Core Data zorgt nu voor die class. Verwijder het Notitie.swift-bestand uit je project, bijvoorbeeld door er in de File Navigator op te Control-klikken en Delete te kiezen.

We verwijderen een bestand uit het project

Kies Move to Trash om het bestand in de Prullenbak te zetten: we hebben het niet langer nodig.

De Core Data Stack

Core Data is een framework dat het opslaan (en opvragen) van gegevens bijna ‘transparant’ maakt: het gebeurt zonder dat je veel voor hoeft te doen. In deze artikelenserie zul je zien dat er heel weinig code nodig is om Core Data voor je te laten werken.

Bij het werken met Core Data gebruik je de zogenaamde Core Data Stack: vier onderdelen die met elkaar samenwerken. In het vorige artikel hebben we met het datamodel (de object graph) kennisgemaakt: de beschrijving van de structuur van de data. De overige drie onderdelen bespreken we nu even.

Core Data Stack: de onderdelen

Persistent Store

De Persistent Store is het bestand waarin de data wordt bewaard. Dit bestand kan, afhankelijk van waar je Core Data gebruikt, verschillende formaten hebben: Binary of SQLLite (bij iOS) en/of XML (bij MacOS).

Het bij de Persistent Store behorende bestand vind je in de Documents-directory die bij je app hoort. Maar… je werkt nooit zelf met de Persistent Store! Dat laat je altijd door Core Data doen.

Persistent Store Coordinator

De Persistent Store Coordinator regelt alles wat met de Persistent Store te maken heeft. Om met de Persistent Store te kunnen werken, gebruikt de Persistent Store Coordinator het datamodel (de object graph).

Wat voor de Persistent Store geldt, geldt ook voor de Persistent Store Coordinator: je werkt er zelf niet mee, maar laat dat aan Core Data over.

Managed Object Context

Telkens als je via Core Data gegevens ophaalt of bewaart, doe je dat via een Managed Object Context. Deze context werkt nauw samen met de Persistent Store Coordinator. De Managed Object Context is dus jouw toegang tot de gegevens die door Core Data worden bewaard. Zodra je gegevens wijzigt of toevoegt, maak je die wijzigingen definitief door de context opdracht te geven die gegevens te ‘bewaren’.

De Persistent Container

De Core Data Stack bestaat uit de vier zojuist genoemde onderdelen:

  • Het datamodel
  • De Persistent Store
  • De Persistent Store Coordinator
  • Een Managed Object Context

Er bestaat een speciale class om met zo min mogelijk rompslomp met de Core Data Stack te kunnen werken: NSPersistentContainer. Deze class doet bijna al het werk: het enige dat hij nodig heeft om de complete Core Data Stack te kunnen opzetten, is de naam van het datamodel. Zodra de Core Data Stack bestaat, kun je met een speciale property, .viewContext aan een bruikbare context komen waarmee je informatie kunt opslaan.

Samenvatting: werken met de Core Data Stack

Om met de Core Data Stack te kunnen werken, doe je dus het volgende:

  1. Je maakt een datamodel.
  2. Je maakt een container, een object van de class NSPersistentContainer. Daarmee heb je een complete Core Data Stack gecreëerd.
  3. Je maakt of wijzigt gegevens via één of meer instanties van NSManagedObject (zoals de Notitie-class).
  4. Je geeft de context (via de .viewContext-property van de container) opdracht om de gegevens op schijf te bewaren.

Stap 2: Verplaats de Core Data-code van de App Delegate naar het model

In het eerste artikel uit deze serie hebben we aangegeven dat onze app met Core Data werkt. Als gevolg daarvan is er flink wat code toegevoegd aan het AppDelegate.swift-bestand:

De commentaarregels zijn uit deze code verwijderd.

De Core Data-code in AppDelegate.swift

Nu je weet hoe een Core Data Stack in elkaar zit, is bovenstaande code eenvoudig te begrijpen. Ze bestaat uit twee onderdelen: een property, .persistentContainer, en een methode, .saveContext().

  • De .persistentContainer-property zorgt voor het opzetten van de complete Core Data Stack en geeft een container terug: een object van de class NSPersistentContainer. Via properties in deze container heb je toegang tot alle onderdelen van de Core Data Stack, maar de enige die je nodig hebt, is de context: .viewContext.
  • De .saveContext()-methode maakt alle wijzigingen die je aan Core Data hebt doorgegeven, definitief door ze in de Persistent Store op te slaan. Telkens als je dus gegevens ‘op schijf’ wilt bewaren, doe je dat door de .saveContext()-methode aan te roepen.

Omdat we in ons model (de class in het Model.swift-bestand) regelmatig met Core Data zullen werken, verplaatsen we deze programmacode naar Model.swift.

Bovenaan in Model.swift zorgen we ervoor dat het model met Core Data kan werken:

Verplaats nu de Core Data-code vanuit AppDelegate.swift naar Model.swift. Het gaat dus om de property .persistentContainer en de functie .saveContext().

Tot slot moeten we nog één ding in de App Delegate aanpassen. De .saveContext()-methode staat niet langer in AppDelegate, maar in Model.

Hiermee hebben we ons Model uitgebreid met Core Data-functionaliteit.

Stap 3: Wijzig het model zodat er geen prototype-data meer wordt getoond

We willen geen prototype-gegevens meer laten tonen. Pas, in het Model, de .count-property aan:

De complete programmacode van Model.swift ziet er nu als volgt uit:

Stap 4: Wijzig de code in de ViewController

Beide properties uit de Notitie-class, .titel en .datum, zijn nu optionals geworden. Bovendien is .datum in de Core Data-versie van onze Notitie-class een NSDate? en geen Date.

Bij het tonen van de notities in onze tabel moeten we dus iets veranderen: we werken niet langer met Date-waarden maar met een NSDate-object. De volgende methode passen we aan, in ViewController.swift:

We moeten notitie.datum downcasten, van een NSDate? optional naar een impliciet uitgepakte Date!-optional:

De gewijzigde methode wordt dus:

Test je app

Omdat het model nu aangeeft dat er geen items zijn, krijgen we een lege tabel te zien:

Onze app, nu zonder dummy-data

Tot slot

Het lijkt alsof er niet veel is gebeurd, maar het tegendeel is waar. We hebben een (werkend) datamodel voor onze app gemaakt en we hebben een werkende Notitie-class. In de volgende aflevering komt alles bij elkaar: we leren hoe we notities moeten toevoegen (en opslaan) en we zien die notities vervolgens in de tabel verschijnen.

Klik hier om de Xcode-bestanden van dit artikel te downloaden.

In één dag Core Data leren?

In deze nieuwe LIVE Clinic over Core Data leer je in één dag hoe je zelf Core Data in je apps kunt gebruiken. Gewoon thuis, vanachter je Mac!

Meer informatie