Een inleidende Core Data-tutorial

Als je dit leest, ga ik ervan uit dat je nieuw bent in Core Data. Misschien heb je over Core Data gehoord en wil je weten of het iets voor jou is of voor het project waaraan je werkt. Als deze beschrijving bij je past, neem dan plaats. In deze Core Data-tutorial leert u alles wat u moet weten om beter te begrijpen wat Core Data wel en niet is.

Wat is Core Data

Ontwikkelaars die nieuw zijn in het framework nemen heel vaak niet de tijd om te leren wat Core Data is. Niet weten wat Core Data is, maakt het erg moeilijk om de ins en outs te begrijpen. Ik wil een paar minuten besteden aan het verkennen van de aard van Core Data en, nog belangrijker, verduidelijken wat Core Data wel en niet is.

Wat zijn de oorsprongen

Core Data is een raamwerk dat is ontwikkeld en wordt onderhouden door Apple. Het bestaat al meer dan tien jaar en het verscheen voor het eerst op macOS met de release van macOS Tiger in 2005. In 2009 maakte het bedrijf het framework beschikbaar op iOS met de release van iOS 3.

Waar past het in

Core Data is de M in MVC, de modellaag van je applicatie. Hoewel Core Data gegevens op schijf kan bewaren, is dat eigenlijk een optionele functie van het framework. Core Data is in de eerste plaats een framework voor het beheer van een object graph.

Je hebt waarschijnlijk al over Core Data gehoord en gelezen voordat je deze cursus volgde. Dat betekent dat je misschien al weet dat Core Data geen database is en dat het de objectgrafiek van je applicatie beheert. Beide beweringen zijn waar. Maar wat betekenen ze eigenlijk?

Beheer van een Object Graph

Core Data beheert eerst en vooral een object graph. Een objectgrafiek is niets meer dan een verzameling objecten die met elkaar verbonden zijn. Het Core Data-framework blinkt uit in het beheer van complexe objectgrafieken.

Het zorgt voor het beheer van de levenscyclus van de objecten in de objectgrafiek en kan de objectgrafiek optioneel op schijf bewaren. Het biedt ook een krachtige interface voor het doorzoeken van de beheerde objectgrafiek.

Maar Core Data is veel meer dan dat. Het framework voegt een aantal andere overtuigende functies, zoals input validatie, data model versioning, en change tracking.

Wanneer Core Data te gebruiken

Het framework is een perfecte pasvorm voor een breed scala van toepassingen, maar niet elke applicatie zou Core Data moeten gebruiken. Toepassingen die een lichtgewicht modellaag nodig hebben, zouden Core Data niet moeten gebruiken. Er zijn veel lichtgewicht bibliotheken die dit soort functionaliteit bieden.

Als je op zoek bent naar een SQLite-wrapper, dan is Core Data ook niet wat je nodig hebt. Voor een lichtgewicht, performante SQLite-wrapper, raad ik je FMDB van Gus Mueller aan. Deze robuuste, volwassen library biedt een object-georiënteerde interface voor interactie met SQLite.

Core Data is een uitstekende keuze als u een oplossing wilt die de modellaag van uw applicatie beheert.

Hoe verschilt het van SQLite

Ontwikkelaars die nieuw zijn met Core Data zijn vaak in de war door de verschillen tussen SQLite en Core Data. Als je je afvraagt of je SQLite of Core Data nodig hebt, dan stel je de verkeerde vraag. Onthoud dat Core Data geen database is.

SQLite

SQLite is een lichtgewicht database die zeer performant is, en daarom goed geschikt voor mobiele toepassingen. Hoewel SQLite wordt geadverteerd als een relationele database, is het belangrijk om te beseffen dat u, de ontwikkelaar, verantwoordelijk bent voor het onderhouden van de relaties tussen records die zijn opgeslagen in de database.

Core Data

Core Data gaat veel verder. Het biedt een abstractie die u toestaat om met de modellaag op een object-georiënteerde manier te interageren. Elk record waarmee u interageert, is een object. Core Data is verantwoordelijk voor de integriteit van de objectgrafiek. Het zorgt ervoor dat de object graph up-to-date wordt gehouden.

Core Data Beperkingen

Ondanks dat Core Data een fantastisch framework is, zijn er een aantal nadelen. Deze nadelen zijn direct gerelateerd aan de aard van het raamwerk en hoe het werkt.

Core Data kan alleen zijn magie doen omdat het de objectgrafiek die het beheert in het geheugen houdt. Dit betekent dat het records alleen kan bewerken als ze zich in het geheugen bevinden. Dit is heel anders dan het uitvoeren van een SQL query op een database. Als je duizenden records wil verwijderen, moet Core Data eerst elk record in het geheugen laden. Het spreekt voor zich dat dit tot geheugen- en prestatieproblemen leidt als het verkeerd wordt uitgevoerd.

Een andere belangrijke beperking is het threading-model van Core Data. Het framework verwacht dat het op een enkele thread wordt uitgevoerd. Gelukkig is Core Data in de loop der jaren sterk geëvolueerd en heeft het framework diverse oplossingen aangedragen om het werken met Core Data in een multithreaded omgeving veiliger en eenvoudiger te maken.

Voor toepassingen die een complexe objectgrafiek moeten beheren, is Core Data een geweldige pasvorm. Als u slechts een handvol niet-gerelateerde objecten hoeft op te slaan, dan bent u misschien beter af met een lichtgewicht oplossing of het standaardsysteem voor gebruikers.

De Core Data-stack verkennen

Nu u weet wat Core Data is en wat het niet is, is het tijd om in te zoomen op de bouwstenen van het framework. Het is van essentieel belang dat u begrijpt hoe de verschillende klassen die het framework doen werken, samenwerken.

De sterren van het framework zijn:

• het beheerde objectmodel
• de beheerde objectcontext
• en de persistente opslagcoördinator

Dit diagram laat zien hoe deze klassen zich tot elkaar verhouden. Laten we beginnen met het beheerde objectmodel.

Beheerd objectmodel

Het beheerde objectmodel is een instantie van de klasse NSManagedObjectModel. Hoewel een typische Core Data-toepassing één instantie van de NSManagedObjectModel klasse heeft, is het mogelijk om er meerdere te hebben. De instantie van het beheerde objectmodel vertegenwoordigt het gegevensmodel van de Core Data-toepassing.

Het bovenstaande diagram toont aan dat het beheerde objectmodel is verbonden met het gegevensmodel. Het gegevensmodel wordt vertegenwoordigd door een bestand in de applicatiebundel dat het gegevensschema van de applicatie bevat. Het gegevensschema is niets meer dan een verzameling entiteiten.

Een entiteit kan attributen en relaties hebben, die samen het gegevensmodel van de applicatie vormen. Onthoud voor nu dat het beheerde objectmodel een instantie is van de klasse NSManagedObjectModel en dat het het gegevensmodel van de Core Data-applicatie vertegenwoordigt.

Beheerde objectcontext

Een beheerde objectcontext wordt vertegenwoordigd door een instantie van de klasse NSManagedObjectContext. Een Core Data-toepassing heeft een of meer beheerde objectcontexten, die elk een verzameling modelobjecten beheren, instanties van de klasse NSManagedObject.

Het diagram dat we eerder hebben verkend, illustreert dat de beheerde objectcontext modelobjecten ontvangt via een persistente opslagcoördinator. Het houdt een verwijzing naar de persistente winkel coördinator van de toepassing.

De beheerde object context is het object dat u de meeste interactie met. Het creëert, leest, actualiseert en verwijdert model objecten. Vanuit het perspectief van een ontwikkelaar is de NSManagedObjectContext klasse het werkpaard van het Core Data framework.

Persistent Store Coordinator

De persistent store coördinator wordt vertegenwoordigd door een instantie van de NSPersistentStoreCoordinator klasse en het speelt een sleutelrol in elke Core Data applicatie. Hoewel het mogelijk is om meerdere persistente store coordinators te hebben, hebben de meeste applicaties er maar één. Zeer, zeer zelden is het nodig om meerdere persistent store coordinators in een applicatie te hebben.

De persistent store coordinator houdt een verwijzing bij naar het managed object model en elke parent managed object context houdt een verwijzing bij naar de persistent store coordinator. Maak je geen zorgen over ouder en kind beheerde object contexten voor nu.

Het bovenstaande diagram toont ons dat een persistente winkel coördinator is verbonden met een of meer persistente winkels. Dit brengt ons bij de persistente opslag.

Persistente opslag

Houd in gedachten dat Core Data een objectgrafiek beheert. Het raamwerk is slechts nuttig als de persistente opslagcoördinator aan één of meerdere persistente opslag wordt verbonden. Out of the box ondersteunt Core Data drie persistente opslagtypes:

• een SQLite database
• een binaire opslag

– een in-memory opslag

Elk persistent opslagtype heeft zijn voor- en nadelen. De meeste toepassingen gebruiken een SQLite database als hun persistente opslag. Zoals ik al eerder zei, SQLite is lichtgewicht en zeer snel. Het is zeer geschikt voor mobiele en desktop applicaties.

Hoe werkt de Core Data Stack

Nu u weet waar de Core Data stack uit bestaat, is het tijd om te onderzoeken hoe het werkt in een applicatie. Het hart van een Core Data applicatie is de persistente opslag coördinator. De persistente opslagcoördinator wordt als eerste geïnstantieerd wanneer de Core Data-stack wordt gemaakt.

Maar om de persistente opslagcoördinator te maken, hebben we een beheerd objectmodel nodig. Waarom is dat? De persistente opslagcoördinator moet weten hoe het gegevensschema van de toepassing eruitziet.

Na het instellen van de persistente opslagcoördinator en het beheerde objectmodel, wordt het werkpaard van de Core Data-stack geïnitialiseerd, de beheerde objectcontext. Vergeet niet dat een beheerde objectcontext een verwijzing naar de persistente opslagcoördinator bijhoudt.

Met de Core Data-stack ingesteld, is de toepassing klaar om Core Data te gebruiken voor interactie met de persistente opslag van de toepassing. In de meeste gevallen heeft uw toepassing interactie met de persistente opslagcoördinator via de beheerde objectcontext.

U zult zelden of nooit directe interactie hebben met de persistente opslagcoördinator of het beheerde objectmodel. Zoals ik al eerder zei, is de NSManagedObjectContext-klasse de klasse waarmee u het meest te maken hebt.

De beheerde objectcontext wordt gebruikt om records te maken, te lezen, bij te werken en te verwijderen. Wanneer de wijzigingen die in het beheerde object context worden opgeslagen, het beheerde object context duwt ze naar de persistente winkel coördinator, die stuurt de wijzigingen naar de overeenkomstige persistente winkel.

Als uw toepassing meerdere persistente stores heeft, zoekt de persistent store-coördinator uit welke persistente store de wijzigingen van de beheerde objectcontext moet opslaan.

In een notendop

U kent nu de basisprincipes van het Core Data-framework. Je loopt al voor op de curve, omdat de meeste ontwikkelaars deze stap overslaan. De volgende stap die je moet nemen is het framework gaan gebruiken. Als je hulp nodig hebt, raad ik je Mastering Core Data With Swift aan.