Aan de slag met Core Data Tutorial

dit is een verkort hoofdstuk uit ons boek Core Data by Tutorials, dat volledig is bijgewerkt voor Swift 4.2 en iOS 12. Deze tutorial wordt gepresenteerd als onderdeel van onze iOS 12 Launch Party — enjoy!

Welkom bij Core Data!

in deze tutorial schrijf je je allereerste Core Data app. U zult zien hoe gemakkelijk het is om aan de slag te gaan met alle middelen die in Xcode worden geleverd, van starter code sjablonen tot de data Model editor.

vanaf het begin ga je de grond raken. Tegen het einde van de tutorial Weet je hoe je:

• modelgegevens met behulp van Xcode ‘ s model editor
• Voeg nieuwe records toe aan Core Data
• haal een set records op Uit Core Data
• Toon de opgehaalde records met behulp van een tabelweergave.

u krijgt ook een idee van wat kerngegevens achter de schermen doen en hoe u kunt interageren met de verschillende bewegende stukken.

aan de slag

Open Xcode en maak een nieuw iOS-project op basis van de Single View App template. Noem de app HitList en zorg ervoor dat het gebruik van kerngegevens is gecontroleerd.

door het vakje Core Data gebruiken aan te vinken zal Xcode boilerplate code genereren voor wat bekend staat als een NSPersistentContainer in AppDelegate.snel.

de NSPersistentContainer bestaat uit een verzameling objecten die het opslaan en opvragen van informatie uit kerngegevens vergemakkelijken. In deze container bevindt zich een object om de Kerngegevensstatus als geheel te beheren, Een object dat het gegevensmodel vertegenwoordigt, enzovoort.

de standaard stack werkt goed voor de meeste apps, maar afhankelijk van uw app en zijn gegevensvereisten, kunt u de stack aanpassen om efficiënter te zijn.

het idee voor deze voorbeeldapp is eenvoudig: er zal een tabelweergave zijn met een lijst met namen voor uw eigen “hitlijst”. U zult in staat zijn om namen toe te voegen aan deze lijst, en uiteindelijk, gebruik maken van Core Data om ervoor te zorgen dat de gegevens worden opgeslagen tussen de sessies. We don ‘ t goedkeuren geweld op deze site, dus je kunt denken aan deze app als een favorieten lijst om bij te houden van je vrienden te houden, natuurlijk!

klik op Main.storyboard om het te openen in Interface Builder. Selecteer de weergavecontroller op het canvas en sluit deze in een navigatiecontroller. Selecteer in het menu Editor van Xcode insluiten … ▸ navigatiecontroller.

klik op de navigatiebalk van de navigatiecontroller om het te selecteren, klik vervolgens op de voorkeur grote titels in de attributen Inspector. Dit geeft de voorbeeldapp een titelstijl die overeenkomt met Apple ‘ s stock apps.

sleep vervolgens een tabelweergave vanuit de objectbibliotheek naar de weergavecontroller en wijzig het formaat ervan zodat het de hele weergave dekt.

indien deze nog niet geopend is, gebruikt u het pictogram in de linkerbenedenhoek van uw canvas om de documentomtrek van Interface Builder te openen.

Ctrl-sleep vanuit de tabelweergave in de documentomtrek naar de bovenliggende weergave en selecteer de voorloopruimte naar de beperking van het veilige gebied:

doe dit nog drie keer, het selecteren van de beperkingen Trailing ruimte naar veilig gebied, bovenste ruimte naar veilig gebied en tot slot, onderste ruimte naar veilig gebied. Door deze vier beperkingen toe te voegen zal de tabelweergave zijn bovenliggende weergave vullen.

sleep vervolgens een Balkknop-Item en plaats het op de navigatiebalk van de weergavecontroller. Tot slot, selecteer de bar knop item en wijzig het systeem item toe te voegen.

uw canvas ziet er ongeveer hetzelfde uit als de volgende schermafbeelding:

elke keer dat u op de knop toevoegen tikt, verschijnt er een waarschuwingscontroller met een tekstveld. Vanaf daar kun je iemands naam typen in het tekstveld. Als u op Save tikt, wordt de naam opgeslagen, wordt de waarschuwingscontroller verwijderd en wordt de tabelweergave vernieuwd, waarbij alle namen worden weergegeven die u hebt ingevoerd.

maar eerst moet u van de weergavecontroller de gegevensbron van de tabelweergave maken. In het canvas, Ctrl-sleep van de tabelweergave naar de gele weergave controller pictogram boven de navigatiebalk, zoals hieronder getoond, en klik op dataSource:

In het geval u zich afvraagt, hoeft u de gedelegeerde van de tabelweergave niet in te stellen, omdat tikken op de cellen geen actie zal veroorzaken. Het wordt niet eenvoudiger dan dit!

Open de assistent-editor door op Command-Option-Enter te drukken of door de middelste knop op de Editor-toolset op de Xcodebalk te selecteren.

Ctrl-sleep vanuit de tabelweergave naar ViewController.swift binnen de klasse definitie om een IBOutletaan te maken.

geef vervolgens de nieuwe IBOutlet eigenschap tableView een naam, wat resulteert in de volgende regel:

@IBOutlet weak var tableView: UITableView!

volgende, Ctrl-sleep vanaf de knop Toevoegen naar de weergavecontroller.swift net onder uw viewDidLoad() definitie. Maak deze keer een actie aan in plaats van een outlet, met de naam van de methode addName, met een type UIBarButtonItem:

@IBAction func addName(_ sender: UIBarButtonItem) { }

u kunt nu verwijzen naar de tabelweergave en de actie van het item van de barknop in code.

Vervolgens stelt u het model in voor de tabelweergave. Voeg de volgende eigenschap toe aan ViewController.swift onder de tableView IBOutlet:

var names: = 

names is een veranderlijke array met tekenreekswaarden die worden weergegeven door de tabelweergave. Vervang vervolgens de implementatie van viewDidLoad() door de volgende:

override func viewDidLoad() { super.viewDidLoad() title = "The List" tableView.register(UITableViewCell.self, forCellReuseIdentifier: "Cell")}

dit stelt een titel in op de navigatiebalk en registreert de UITableViewCell klasse met de tabelweergave.

volgende, nog steeds in ViewController.swift, voeg de volgende UITableViewDataSource extensie toe onder uw klasse definitie voor ViewController:

// MARK: - UITableViewDataSourceextension ViewController: UITableViewDataSource { func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return names.count } func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) cell.textLabel?.text = names return cell }}

Als u ooit met UITableView hebt gewerkt, moet deze code er erg bekend uitzien. Eerst retourneert u het aantal rijen in de tabel als het aantal items in uw names array.

Next, tableView(_:cellForRowAt:) dequeues tabelweergave cellen en vult ze met de corresponderende tekenreeks uit de names array.

vervolgens hebt u een manier nodig om nieuwe namen toe te voegen zodat de tabelweergave ze kan weergeven. Implementeer de addName IBAction methode die u Ctrl-gesleept in uw code eerder:

// Implement the addName IBAction@IBAction func addName(_ sender: UIBarButtonItem) { let alert = UIAlertController(title: "New Name", message: "Add a new name", preferredStyle: .alert) let saveAction = UIAlertAction(title: "Save", style: .default) { action in guard let textField = alert.textFields?.first, let nameToSave = textField.text else { return } self.names.append(nameToSave) self.tableView.reloadData() } let cancelAction = UIAlertAction(title: "Cancel", style: .cancel) alert.addTextField() alert.addAction(saveAction) alert.addAction(cancelAction) present(alert, animated: true)}

elke keer dat u op de knop toevoegen tikt, zal deze methode een UIAlertController weergeven met een tekstveld en twee knoppen: Opslaan en annuleren.

Save voegt de tekstvelden in de huidige tekst in de names array en laadt vervolgens de tabelweergave opnieuw. Aangezien de names array het model is dat achter de tabelweergave staat, zal alles wat u typt in het tekstveld verschijnen in de tabelweergave.

ten slotte, bouw en voer uw app voor de eerste keer. Tik vervolgens op de knop Toevoegen. De alert controller zal er zo uitzien:

voeg vier of vijf namen toe aan de lijst. Je zou iets dergelijks moeten zien als hieronder:

uw tabelweergave zal de gegevens weergeven en uw array zal de namen opslaan, maar het grote ding dat hier ontbreekt is persistentie. De array is in het geheugen, maar als je kracht stoppen met de app of reboot uw apparaat, uw hitlijst zal worden weggevaagd. Core Data biedt persistentie, wat betekent dat het gegevens kan opslaan in een duurzamere staat, zodat het kan overleven een app re-launch of een apparaat reboot.

u hebt nog geen kerngegevens toegevoegd, dus er mag niets blijven bestaan nadat u weg bent gegaan van de app. Laten we dit testen. Druk op de Home-knop als u een fysiek apparaat gebruikt of het equivalent (Shift + ⌘ + H) Als u de Simulator gebruikt. Dit brengt u terug naar de vertrouwde app grid op het startscherm:

tik in het beginscherm op het pictogram hitlijst om de app terug naar de voorgrond te brengen. De namen staan nog steeds op het scherm. Wat is er gebeurd?

wanneer u op de Home-knop tikt, gaat de app op de voorgrond naar de achtergrond. Wanneer dit gebeurt, het besturingssysteem flash-bevriest alles wat momenteel in het geheugen, met inbegrip van de strings in de namen array. Evenzo, als het tijd is om wakker te worden en terug te keren naar de voorgrond, het besturingssysteem herstelt wat vroeger in het geheugen alsof je nooit had verlaten.

Apple introduceerde deze verbeteringen in multitasking terug in iOS 4. Ze creëren een naadloze ervaring voor iOS-gebruikers, maar voegen een rimpel toe aan de definitie van persistentie voor iOS-ontwikkelaars. Zijn de namen echt volgehouden?

Nee, niet echt. Als u de app in de snelle app switcher volledig had gedood of uw telefoon had uitgeschakeld, zouden die namen zijn verdwenen. U kunt dit ook controleren. Met de app op de voorgrond, voer de snelle app switcher. U kunt dit doen door dubbel te tikken op de Home-knop als uw apparaat heeft een of langzaam naar boven te slepen vanaf de onderkant van het scherm als je op een iPhone X.

vanaf hier, veeg de HitList app snapshot omhoog om de app te beëindigen. Als je werkt aan een iPhone X, je moet lang-druk op de app snapshot totdat een rode knop Verwijderen verschijnt in de rechterbovenhoek.

nadat u de app uit de app-switcher hebt verwijderd, mag er geen spoor van HitList in het levende geheugen zijn (geen woordspeling bedoeld). Controleer of de namen zijn verdwenen door terug te keren naar het startscherm en te tikken op de HitList icoon om een nieuwe lancering te activeren.

het verschil tussen invriezen en persistentie kan duidelijk zijn als u al enige tijd met iOS werkt en bekend bent met de manier waarop multitasking werkt. In de geest van een gebruiker is er echter geen verschil. De gebruiker maakt het niet uit waarom de namen zijn er nog steeds, of de app ging naar de achtergrond en kwam terug, of omdat de app opgeslagen en opnieuw geladen hen. Het enige dat telt is de namen zijn er nog steeds als de app komt terug!

dus de echte test van persistentie is of uw gegevens er nog steeds zijn na een nieuwe app-lancering.

modelleren van uw gegevens

Nu u weet hoe u moet controleren op persistentie, kunt u in de kerngegevens duiken. Uw doel voor de HitList app is eenvoudig: blijf de namen die u invoert, zodat ze beschikbaar zijn voor het bekijken na een nieuwe app lancering.

tot nu toe gebruikte u gewone Swift-tekenreeksen om de namen in het geheugen op te slaan. In deze sectie vervangt u deze strings door Core Data-objecten.

de eerste stap is het maken van een managed object model, dat de manier beschrijft waarop kerngegevens gegevens op schijf vertegenwoordigen.

standaard gebruikt Core Data een SQLite-database als de permanente opslag, zodat u het gegevensmodel kunt zien als het databaseschema.

omdat u ervoor hebt gekozen om kerngegevens te gebruiken, heeft Xcode automatisch een gegevensmodel-bestand voor u aangemaakt en het HitList genoemd.xcdatamodeld.

Open HitList.xcdatamodeld. Zoals u kunt zien, Xcode heeft een krachtige data Model editor:

de data Model editor heeft veel functies die u later kunt verkennen. Voor nu, laten we ons richten op het creëren van een enkele kern data-entiteit.

klik linksonder op entiteit toevoegen om een nieuwe entiteit aan te maken. Dubbelklik op de nieuwe entiteit en verander haar naam in persoon, zoals zo:

u vraagt zich misschien af waarom de model editor de term Entity. gebruikt. definieerde u niet gewoon een nieuwe klasse? Zoals u binnenkort zult zien, Core Data wordt geleverd met een eigen woordenschat. Hier is een kort overzicht van enkele termen die u vaak tegenkomt:

• een entiteit is een klassendefinitie in kerngegevens. Het klassieke voorbeeld is een Employee of een Company. In een relationele database komt een entiteit overeen met een tabel.
• een eigenschap is een stuk informatie dat aan een bepaalde entiteit is gekoppeld. Een Employee entiteit kan bijvoorbeeld kenmerken hebben voor name, position en salaryvan de werknemer. In een database komt een attribuut overeen met een bepaald veld in een tabel.
• een relatie is een koppeling tussen meerdere entiteiten. In kerngegevens worden relaties tussen twee entiteiten tot-één relaties geroepen, terwijl die tussen één en vele entiteiten tot-vele relaties worden geroepen. Zo kan een Manager een tot-veel relatie hebben met een groep werknemers, terwijl een individu Employee gewoonlijk een tot-één relatie heeft met zijn manager.

Nu u weet wat een attribuut is, kunt u een attribuut toevoegen aan Person eerder aangemaakt object. Nog steeds in HitList.xcdatamodeld, selecteer Person aan de linkerkant en klik op het plusteken ( + ) onder attributen.

Stel de naam van het nieuwe attribuut in op, er, name en verander het type In String:

in Core Data kan een attribuut van een van de verschillende gegevenstypen zijn.

opslaan naar kerngegevens

Open ViewController.swift, voeg de volgende Core Data module import onder de UIKit import:

import CoreData

deze import is alles wat je nodig hebt om te beginnen met het gebruik van de Core Data API in uw code.

volgende, vervang de definitie names door de volgende:

var people: = 

u slaat Person entiteiten op in plaats van stringnamen, dus u hernoemt de array die dienst doet als gegevensmodel voor de tabelweergave naar people. Het bevat nu instanties van NSManagedObject in plaats van eenvoudige strings.

NSManagedObject vertegenwoordigt een enkel object opgeslagen in de kerngegevens; u moet het gebruiken om te maken, bewerken, opslaan en verwijderen uit uw kerngegevens persistent store. Zoals u binnenkort zult zien, is NSManagedObject een vormveranderaar. Het kan de vorm aannemen van elke entiteit in uw datamodel, waarbij u zich de eigenschappen en relaties toe-eigent die u hebt gedefinieerd.

omdat u het model van de tabelweergave wijzigt, moet u ook beide eerder geà mplementeerde gegevensbronmethoden vervangen. Vervang uw UITableViewDataSource extensie door de volgende:

// MARK: - UITableViewDataSourceextension ViewController: UITableViewDataSource { func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return people.count } func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let person = people let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) cell.textLabel?.text = person.value(forKeyPath: "name") as? String return cell }}

de belangrijkste wijziging van deze methoden vindt plaats in tableView(_:cellForRowAt:). In plaats van cellen te matchen met de corresponderende tekenreeks in de model-array, matcht u nu cellen met de corresponderende NSManagedObject.

merk op hoe u het name attribuut van de NSManagedObjectpakt. Het gebeurt hier.:

cell.textLabel?.text = person.value(forKeyPath: "name") as? String

Waarom moet je dit doen? Het blijkt dat NSManagedObject niet op de hoogte is van het name attribuut dat u hebt gedefinieerd in uw datamodel, dus er is geen manier om het direct te benaderen met een eigenschap. De enige manier die de kerngegevens verstrekken om de waarde te lezen is sleutel-waardecodage, algemeen als KVC wordt bedoeld.

volgende, zoek addName(_:) en vervang save UIAlertAction door de volgende:

let saveAction = UIAlertAction(title: "Save", style: .default) { action in guard let textField = alert.textFields?.first, let nameToSave = textField.text else { return } self.save(name: nameToSave) self.tableView.reloadData()}

dit neemt de tekst in het tekstveld en geeft het door aan een nieuwe methode genaamd save(name:). Xcode klaagt omdat save(name:) nog niet bestaat. Voeg het hieronder toe addName(_:):

func save(name: String) { guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return } // 1 let managedContext = appDelegate.persistentContainer.viewContext // 2 let entity = NSEntityDescription.entity(forEntityName: "Person", in: managedContext)! let person = NSManagedObject(entity: entity, insertInto: managedContext) // 3 person.setValue(name, forKeyPath: "name") // 4 do { try managedContext.save() people.append(person) } catch let error as NSError { print("Could not save. \(error), \(error.userInfo)") }}

Dit is waar Core Data werkt! Dit is wat de code doet:

1. voordat u iets uit uw Core data store kunt opslaan of ophalen, moet u eerst een NSManagedObjectContextin handen krijgen. U kunt een beheerde ObjectContext beschouwen als een in-memory “scratchpad” voor het werken met beheerde objecten.

   denk aan het opslaan van een nieuw beheerd object in kerngegevens als een proces in twee stappen: eerst voegt u een nieuw beheerd object in een beheerde ObjectContext; als u tevreden bent, “commit” u de wijzigingen in uw beheerde ObjectContext om het op schijf op te slaan.

   Xcode heeft al een beheerde ObjectContext gegenereerd als onderdeel van het sjabloon van het nieuwe project. Onthoud dat dit alleen gebeurt als u het selectievakje Core Data gebruiken aan het begin aanvinkt. Deze standaard beheerde ObjectContext leeft als een eigenschap van de NSPersistentContainer in de application delegate. Om toegang te krijgen, krijg je eerst een verwijzing naar de app delegate.

2. u maakt een nieuw beheerd object aan en plaatst het in de beheerde ObjectContext. U kunt dit in één stap doen met NSManagedObject’s statische methode: entity(forEntityName:in:).

   u vraagt zich misschien af waar een NSEntityDescription over gaat. Vroeger werd NSManagedObject een shape-shifter class genoemd omdat het elke entiteit kan vertegenwoordigen. Een entiteit beschrijving is het stuk dat de entiteit definitie van uw gegevensmodel koppelt aan een instantie van NSManagedObject tijdens runtime.

1. met een NSManagedObject in de hand, stelt u het name attribuut in met behulp van key-value codering. U moet de KVC-sleutel (name in dit geval) precies spellen zoals deze in uw gegevensmodel wordt weergegeven, anders zal uw app crashen tijdens runtime.
2. u commit uw wijzigingen naar person en slaat deze op schijf op door save aan te roepen in de context van het beheerde object. Noot save kan een fout geven, daarom noem je het met het try sleutelwoord binnen een do-catch blok. Tot slot, voeg het nieuwe beheerde object in de people array zodat het verschijnt wanneer de tabelweergave herlaadt.

dat is iets ingewikkelder dan het gebruik van een array van strings, maar niet al te slecht. Een deel van de code hier, zoals het verkrijgen van de beheerde object context en entiteit, kan slechts één keer worden gedaan in uw eigen init() of viewDidLoad() en later opnieuw worden gebruikt. Voor de eenvoud doe je het allemaal op dezelfde manier.

bouw en voer de app uit en voeg een paar namen toe aan de tabelweergave:

als de namen daadwerkelijk zijn opgeslagen in de kerngegevens, de HitList app moet de persistentie test passeren. Met de app op de voorgrond, ga naar de snelle app switcher en vervolgens beëindigen.

tik vanuit Springboard op de HitList-app om een nieuwe lancering te starten. Wacht, Wat is er gebeurd? De tabelweergave is leeg:

u hebt de kerngegevens opgeslagen, maar na het opstarten van een nieuwe app is de people array leeg! Dat komt omdat de gegevens op de schijf op je wachten, maar je laat het nog niet zien.

ophalen van kerngegevens

om gegevens van uw permanente opslag in de beheerde ObjectContext te krijgen, moet u deze ophalen. Open ViewController.swift en voeg hieronder het volgende toe viewDidLoad():

override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated) //1 guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return } let managedContext = appDelegate.persistentContainer.viewContext //2 let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person") //3 do { people = try managedContext.fetch(fetchRequest) } catch let error as NSError { print("Could not fetch. \(error), \(error.userInfo)") }}

stap voor stap, Dit is wat de code doet:

1. voordat u iets met kerngegevens kunt doen, hebt u een beheerde ObjectContext nodig. Ophalen is niet anders! Net als voorheen, trek je de application delegate op en pak je een referentie naar de persistente container om de NSManagedObjectContextin handen te krijgen.
2. zoals de naam al doet vermoeden, is NSFetchRequest de klasse die verantwoordelijk is voor het ophalen van kerngegevens. Fetch-verzoeken zijn zowel krachtig als flexibel. U kunt fetch requests gebruiken om een set objecten op te halen die aan de opgegeven criteria voldoen (d.w.z. geef me alle werknemers die wonen in Wisconsin en zijn met het bedrijf ten minste drie jaar), individuele waarden (dat wil zeggen Geef me de langste naam in de database) en meer.

   Fetch requests hebben verschillende qualifiers gebruikt om de set van resultaten te verfijnen. Voor nu, moet u weten NSEntityDescription is een van deze vereiste qualifiers.

   het instellen van de entity eigenschap van een fetch-verzoek, of het initialiseren met init(entityName:), haalt alle objecten van een bepaalde entiteit op. Dit is wat je hier doet om alle Person entiteiten op te halen. Opmerking NSFetchRequest is een generiek type. Dit gebruik van generics specificeert het verwachte return type van een fetch request, in dit geval NSManagedObject.

3. u geeft het fetch-verzoek over aan de beheerde ObjectContext om het zware werk te doen. fetch(_:) geeft een array van beheerde objecten terug die voldoen aan de criteria die zijn opgegeven door het fetch-verzoek.

bouw en voer de toepassing uit. Onmiddellijk, moet u de lijst met namen die u eerder hebt toegevoegd zien:

geweldig! Ze zijn terug uit de dood (woordspeling bedoeld). Voeg een paar namen toe aan de lijst en herstart de app om te controleren of opslaan en ophalen werkt. Kort van het verwijderen van de app, het resetten van de Simulator of het gooien van uw telefoon uit een hoog gebouw, de namen zullen verschijnen in de tabel weergave ongeacht wat.

Key Points

• Core Data biedt doorzettingsvermogen op de schijf, wat betekent dat uw gegevens toegankelijk zijn, zelfs na het beëindigen van uw app of het afsluiten van uw apparaat. Dit is anders dan in-memory persistentie, die alleen uw gegevens op te slaan zolang uw app is in het geheugen, hetzij op de voorgrond of op de achtergrond.
• Xcode wordt geleverd met een krachtige datamodel-editor, die u kunt gebruiken om uw beheerde objectmodel te maken.
• een beheerd objectmodel bestaat uit entiteiten, attributen en relaties
• een entiteit is een klassedefinitie in kerngegevens.
• een eigenschap is een informatiestuk dat aan een entiteit is gekoppeld.
• een relatie is een koppeling tussen meerdere entiteiten.
• een NSManagedObject is een weergave in runtime van een Kerngegevensentiteit. U kunt lezen en schrijven aan zijn attributen gebruikend sleutel-Waardecodage.
• u hebt een NSManagedObjectContext tot save() of fetch(_:) gegevens van en naar kerngegevens nodig.

waar moet ik nu naartoe?

u kunt het voltooide project voor deze tutorial downloaden met behulp van de “download materialen” knoppen aan de boven-of onderkant van deze tutorial.

in deze tutorial hebt u al verschillende fundamentele Kerngegevensconcepten ervaren: gegevensmodellen, entiteiten, attributen, beheerde objecten, beheerde objectcontexten en fetch-Verzoeken.

Als u genoten van wat je geleerd in deze tutorial, waarom niet Bekijk de volledige Core Data Door Tutorials boek, beschikbaar in onze winkel?

hier is een voorproefje van wat er in het boek staat:

1. Hoofdstuk 1, Uw eerste Core Data App: je klikt bestand New nieuw Project en schrijf een Core Data app vanaf nul! Dit hoofdstuk behandelt de basisprincipes van het opzetten van uw datamodel en vervolgens het toevoegen en ophalen van records.

2. Hoofdstuk 2, Nsmanagedobject subklassen: NSManagedObject is de basis data opslag klasse van uw Core Data object grafieken. Dit hoofdstuk leert u hoe u uw eigen beheerde objectsubklassen aanpast om gegevens op te slaan en te valideren.

3. Hoofdstuk 3, De Core Data Stack: onder de motorkap bestaat Core Data uit vele delen die samenwerken. In dit hoofdstuk leer je hoe deze onderdelen in elkaar passen en ga je weg van de starter Xcode-sjabloon om je eigen aanpasbare systeem te bouwen.

4. Hoofdstuk 4, Intermediate Fetching: uw apps halen gegevens de hele tijd, en Core Data biedt vele opties voor het krijgen van de gegevens om u efficiënt. Dit hoofdstuk behandelt meer geavanceerde fetch-Verzoeken, predicaten, sorteren en asynchrone fetching.

5. Hoofdstuk 5, NSFetchedResultsController: Table views zijn de kern van veel iOS-apps, en Apple wil Core Data spelen mooi met hen! In dit hoofdstuk leert u hoe NSFetchedResultsController u tijd en code kan besparen wanneer uw tabelweergaven worden ondersteund door gegevens uit kerngegevens.

6. Hoofdstuk 6, versiebeheer en migratie: Als u uw app bijwerkt en verbetert, zal het datamodel vrijwel zeker moeten veranderen. In dit hoofdstuk leert u hoe u meerdere versies van uw datamodel kunt maken en vervolgens uw gebruikers kunt migreren zodat ze hun bestaande gegevens kunnen behouden tijdens het upgraden.

7. Hoofdstuk 7, Unit Tests: testen is een belangrijk onderdeel van het ontwikkelingsproces, en je moet Core Data daar niet buiten laten! In dit hoofdstuk leert u hoe u een aparte testomgeving voor kerngegevens instelt en ziet u voorbeelden van hoe u uw modellen kunt testen.

8. Hoofdstuk 8: meten en verbeteren van prestaties: Niemand ooit geklaagd dat een app was te snel, dus het is belangrijk om waakzaam te zijn over het bijhouden van de prestaties. In dit hoofdstuk leert u hoe u de prestaties van uw app kunt meten met verschillende Xcode-tools en vervolgens enkele tips kunt ophalen voor het omgaan met trage plekken in uw code.

9. Hoofdstuk 9, meerdere beheerde Objectcontexten: in dit laatste hoofdstuk breidt u de gebruikelijke Core Data stack uit om meerdere beheerde objectcontexten op te nemen. U leert hoe dit de waargenomen prestaties kan verbeteren en uw app-architectuur minder monolithisch en meer gecompartimenteerd kan maken.

en om de deal te vergemakkelijken, is de digitale editie van het boek te koop voor $44,99! Maar wacht niet-deze verkoopprijs is alleen beschikbaar voor een beperkte tijd.

over zoete deals gesproken, bekijk zeker de geweldige prijzen die we dit jaar weggeven met de iOS 11 Launch Party, inclusief meer dan $ 9.000 in giveaways!

om in aanmerking te komen voor deze epic iOS 12 giveaway, alles wat je hoeft te doen is een reactie achterlaten op de oorspronkelijke launch post, laat ons weten welk boek of cursus is uw favoriet op deze lijst — of welk aanstaande boek of cursus je het meest enthousiast over bent!

we hopen dat u geniet van deze update, en blijf op de hoogte voor meer boek releases en updates!