Core Data — wat is het, datamodel en hoe het werkt

Wat is Core Data en zijn rol in iOS

Core Data — is een framework voor het beheer van de objectgraaf en persistentie, onderdeel van Cocoa Touch. In tegenstelling tot wat vaak wordt gedacht, is Core Data geen database, maar een objectbeheerlaag die SQLite als een van de opslagmethoden kan gebruiken. De hoofdtaak van Core Data is het volgen van wijzigingen in objecten, het beheren van hun levenscyclus en het synchroniseren van de status met de schijf.

Het framework biedt een objectgraaf, waarbij elke Managed Object door de context wordt gevolgd op wijzigingen. Bij het opslaan van de context worden alle gewijzigde, toegevoegde en verwijderde objecten in één transactie in de permanente opslag bevestigd. Dit bevrijdt de ontwikkelaar van het schrijven van SQL-query's en het handmatig beheren van transacties.

Volgens statistieken van de Swift Developer Survey (2025) wordt Core Data gebruikt in 52% van de iOS-applicaties die met lokale gegevens werken. Ondanks de opkomst van moderne alternatieven (SwiftData, Realm) blijft Core Data het belangrijkste framework in bestaande Apple-projecten vanwege zijn volwassenheid en diepe integratie met het systeem.

Gebruik Core Data voor projecten met een datamodel van gemiddelde complexiteit waar relaties tussen objecten, ongedaan maken van wijzigingen en automatische caching via het faulting-mechanisme nodig zijn.

De architectuur van Core Data is gebouwd rond het concept van Managed Object Context — een werkruimte die alle wijzigingen in objecten bijhoudt. De context ondersteunt ongedaan maken (undo/redo) via de ingebouwde NSUndoManager, waardoor concepten en het annuleren van acties kunnen worden geïmplementeerd zonder handmatig opslaan van statussnapshots. Bij aanroep van save() bevestigt de context alle wijzigingen in één transactie in de permanente opslag, wat atomiciteit en gegevensconsistentie garandeert.

Datamodel: Entity, Attributes, Relationships

Het datamodel van Core Data wordt gedefinieerd in het bestand .xcdatamodeld — de visuele editor van Xcode, waarin alle Entiteiten, hun attributen en relaties worden beschreven. Bij compilatie wordt het model geserialiseerd naar .momd en geladen via NSManagedObjectModel.

Entity en Attributes

Entity — is een beschrijving van het gegevenstype, analoog aan een tabel in SQL. Elke Entity bevat een set Attributes — benoemde velden met een gegevenstype (String, Integer, Date, Boolean, Data). In tegenstelling tot Room vereist Core Data een expliciete typekeuze voor elk attribuut via de modeleditor.

Relationships

Relationship — een relatie tussen Entiteiten, analoog aan een externe sleutel in SQL. Core Data ondersteunt alle typen relaties: een-op-een, een-op-veel en veel-op-veel. Voor elke relatie wordt een Delete Rule (Cascade, Nullify, Deny) geconfigureerd — het gedrag bij het verwijderen van het gerelateerde object.

De keuze van Delete Rule is cruciaal voor de gegevensintegriteit: Cascade kan zonder controle een derde van de database verwijderen, en Deny kan de bewerking blokkeren met een onduidelijke fout. In productiecode wordt Nullify met handmatige verwerking van weesgegevens aanbevolen.

In de Xcode-modeleditor kan de ontwikkelaar niet alleen Entity en attributen instellen, maar ook constraints (uniciteitsbeperkingen), indexen voor het versnellen van query's en default values voor attributen. Alle modelwijzigingen worden gecompileerd naar het .momd-bestand, dat wordt geladen bij initialisatie van NSPersistentContainer. Modelversiebeheer (Model Versioning) maakt het mogelijk meerdere versies van het schema te onderhouden en migratie ertussen uit te voeren.

Core Data-stack: PersistentContainer en Context

NSPersistentContainer — een uniform object dat de Core Data-stack beheert sinds iOS 10 en macOS 10.12. Het inkapselt NSManagedObjectModel, NSPersistentStoreCoordinator en NSManagedObjectContext, en automatiseert het laden van het model en de configuratie van de opslag. Voor oudere versies werd de stack handmatig gebouwd, maar dit wordt nu niet aanbevolen.

let container = NSPersistentContainer(name: "DataModel")
container.loadPersistentStores { _, error in
    if let error { fatalError("Core Data load failed: \(error)") }
}
let context = container.viewContext

viewContext — de hoofdcontext gekoppeld aan de hoofdthread. Alle lees- en UI-updates worden hierdoor uitgevoerd. Voor de prestaties wordt aanbevolen gegevens te schrijven in een onderliggende context met een privé-wachtrij en latere synchronisatie.

NSPersistentStoreCoordinator

De coördinator NSPersistentStoreCoordinator verbindt het model met de fysieke opslag op schijf. Core Data ondersteunt meerdere opslagtypen: SQLite (aanbevolen), Binary en In-Memory. SQLite-opslag ondersteunt migraties, incrementele back-up en foutbestendigheid tijdens het schrijfproces.

NSFetchRequest en werken met gegevens

NSFetchRequest — een object dat een query naar de Core Data-opslag beschrijft. Het bevat de Entity-naam, filterpredikaat, sortering en ophaalinstellingen. De query wordt uitgevoerd via context.fetch(), die een array van NSManagedObject retourneert.

let request = NSFetchRequest<User>(entityName: "User")
request.predicate = NSPredicate(format: "age >= %d", 18)
request.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
request.fetchLimit = 50

let results = try context.fetch(request)

NSPredicate ondersteunt complexe voorwaarden: LIKE, IN, BETWEEN, CONTAINS[c] (hoofdletterongevoelig), SUBQUERY voor geneste query's op gerelateerde Entiteiten. Core Data ondersteunt ook NSFetchedResultsController — een klasse voor reactief laden van gegevens in UITableView, die automatisch wijzigingen bijhoudt en de tabel bijwerkt met geanimeerde secties.

Core Data in een multi-thread omgeving

Werken met Core Data in een multi-thread applicatie vereist strikte naleving van de regels: NSManagedObject mag niet direct tussen threads worden doorgegeven. Elke thread (of wachtrij) moet zijn eigen context gebruiken. De belangrijkste benadering is het maken van een onderliggende NSManagedObjectContext met een privé-wachtrij (NSPrivateQueueConcurrencyType) voor schrijven en viewContext voor lezen.

De onderliggende context wordt opgeslagen in de bovenliggende, en vervolgens de bovenliggende — in de opslag op schijf. Dit garandeert dat wijzigingen de hoofdthread niet blokkeren en dat de UI altijd een consistente status ziet via mergeChanges of automatische update van viewContext bij opslaan.

Core Data gebruikt faulting — een mechanisme voor het uitgesteld laden van gerelateerde objecten. Bij het ophalen van User zonder zijn addresses op te vragen, worden de gerelateerde Addressen niet geladen totdat ze via puntnotatie worden benaderd. Faulting bespaart geheugen en versnelt het laden, maar kan onverwachte schijftoegangen op de hoofdthread veroorzaken als de toegang in achtergrondcontexten niet wordt gecontroleerd.

Voor efficiënte multi-threading gebruikt u NSBatchInsertRequest en NSBatchDeleteRequest voor bulk-invoeging en -verwijdering zonder objecten in het geheugen te laden — dit is cruciaal voor gegevenssynchronisatie met de server.

Batchbewerkingen worden direct uitgevoerd op het niveau van NSPersistentStoreCoordinator, waarbij de context en objectgraaf worden omzeild. Dit maakt het mogelijk om 10.000 records in enkele milliseconden in te voegen zonder 10.000 NSManagedObject-instanties in het geheugen te creëren. Na het uitvoeren van de batch-query moet de context worden bijgewerkt via mergeChangesFromContextDidSaveNotification zodat de UI de nieuwe gegevens weergeeft. Apple beveelt batchbewerkingen aan voor initieel laden van gegevens en nachtelijke synchronisatie met de server.

Voor het bijhouden van wijzigingen in Core Data wordt NSPersistentHistoryTracking gebruikt — een mechanisme dat elke transactie (invoeging, update, verwijdering) in een aparte geschiedenis registreert. Het inschakelen van history tracking maakt het mogelijk gegevens te synchroniseren tussen verschillende processen en applicaties die met hetzelfde SQLite-bestand werken, bijvoorbeeld tussen de hoofdapplicatie en Notification Service Extension. Activering gebeurt via NSPersistentStoreDescription met de vlag persistentHistoryTrackingKey, en lezen via NSPersistentHistoryChangeRequest met filter op datum en transactietype.

Voor debugging en profilering van Core Data-prestaties wordt het hulpprogramma Core Data Profiler uit de Instruments-suite in Xcode op macOS gebruikt. Het toont alle ophaal-, invoeg-, verwijder- en opslagbewerkingen met de duur van elke bewerking en het aantal geladen objecten in tabellen en tijdlijngrafieken. De ontwikkelaar kan probleemgebieden identificeren: meerdere ophaalbewerkingen van dezelfde query (gebrek aan caching), lekkage van fault-objecten bij het scrollen van de tabel of blokkering van de hoofdthread door synchroon laden van gerelateerde entiteiten. Profilering wordt aanbevolen op een echt apparaat, niet op de simulator, omdat de prestaties van de simulator het werkelijke gedrag van de applicatie op iPhone of iPad niet weerspiegelen.