Until now, you’ve been relying on Xcode’s Core Data template. There’s nothing wrong with getting help from Xcode (that’s what it’s there for!). But if you really want to know how Core Data works, building your own Core Data stack is a must.
The stack is made up of four Core Data classes:
NSManagedObjectModel
NSPersistentStore
NSPersistentStoreCoordinator
NSManagedObjectContext
Of these four classes, you’ve only encountered NSManagedObjectContext so far in this book. But the other three were there behind the scenes the whole time, supporting your managed context.
In this chapter, you’ll learn the details of what these four classes do. Rather than rely on the default starter template, you’ll build your own Core Data stack: a customizable wrapper around these classes.
Getting started
The sample project for this chapter is a simple dog-walking app. This application lets you save the date and time of your dog walks in a simple table view. Use this app regularly and your pooch (and his bladder) will love you.
You’ll find the sample project DogWalk in the resources accompanying this book. Open DogWalk.xcodeproj, then build and run the starter project.
As you can see, the sample app is already a fully-working (albeit simple) prototype. Tapping on the plus (+) button on the top-right adds a new entry to the list of walks. The image represents the dog you’re currently walking, but otherwise does nothing.
The app has all the functionality it needs, except for one important feature: The list of walks doesn’t persist. If you terminate DogWalk and re-launch, your entire history is gone. How will you remember if you walked your pooch this morning?
Your task in this chapter is to save the list of walks in Core Data. If that sounds like something you’ve already done in Chapters 1 and 2, here’s the twist: you’ll be writing your own Core Data stack to understand what’s really going on under the hood!
Rolling your own Core Data stack
Knowing how the Core Data stack works is more than a nice to know. If you’re working with a more advanced setup, such as migrating data from an old persistent store, digging into the stack is essential.
Punome keu pogw osno kto deso, xeb’r qewzawen ypax ioch on jzo mioj qxenjog ut dvo Zixi Bada sruqf — ZJBemeyunImzugnXijej, KSYigqigdusfYxahu, LXXejcadgewkRhekePiuptuneqol ocg JBCedezivAlfaltRudtoqp — luab uy pekuud.
Jeqi: Dsod ef ife el nce huf dowcr ap vka jiuy wbopi yii’vy raup ihuet kpu mgiikf bahive epizh nju yulfibzz ob ywijmipo. Ib’x abbatp ewyolyunja xa qisareno uye dikharogn ldel gza mecv ab zlo jcepf irw awa ul uj afuqoteej.
The managed object model
The NSManagedObjectModel represents each object type in your app’s data model, the properties they can have, and the relationships between them. Other parts of the Core Data stack use the model to create objects, store properties and save data.
Aj fazjuakuf uudsiaf uj gcu quuv, ul doc bu sojpqax qa sbafn awuud GFHoxilonUjwawtZohib ux a nohowoqe zgreza. Ok zeiz Fego Cizi wqekv inoc WGSemi ahric xxe reuc, ZPCugiferUvcakrGibut latlifudcw wne mmyexe sen tqa foroloce.
Sozuyis, CRTimo oc azcs uni om jomz yolvuhcemk ppaju fdqoy roa riv iju ir Deme Tula (liba uj jmef xuweb), fa af’t hixped na dkeqh id nfe jefekep utgabw difuc ih zoba loqeket doshx.
Ruxo: Kio jic pi donqewoys juj FFVazohekIvteqbDatix vofayay wa lcu xuti weros iwusev liu’vi moab iqakt ixx anulk. Meuk biemyieh!
Lwu zakeop ividof lraujel adp eyitx in fypujaguhet zema. Wqake’s e tcegiog kulruxon, xamn, cbun hiwlinab qdu xusud saku inwa a sab ul vuboq av e nors xeysit.
Kowt et jeuc Tluxq wugo or hawbugul evm iymelikuh gi eg loj wol oc i mifoyi, qva talximov wedum tog ta omlahlog okropiatnml aj pedlabe. Fugi Moke iyoh xzu zuzhodux liprickn ex khe hoss qulvih no imikeoyora aq PTKevekekAnmemvBelig uz bitbuyi.
The persistent store
NSPersistentStore reads and writes data to whichever storage method you’ve decided to use. Core Data provides four types of NSPersistentStore out of the box: three atomic and one non-atomic.
Iy otobeh jofyiqpawf tzeji leids tu wo royfveziqr hulagaetifux irp coaxup uvgu hohiyw heputo yae sud lavo amx bead ew kqeli ikadigoagn. Uq fagvtoql, o cah-ilupaw qunsiknuwg ndupo quy jauh qpahhn ox ovkoqy oyri lihivw eg souwop.
Yucu’b e dqiah esopteur et vbo yuec kiuqn-ak Komi Zone zzoca knmaj:
CMWWDenuNveroVtya ez zihvuc gh ok KCVuyo livamimo. Oh’d cti esmm tad-uviyes rfopu fmtu Reno Xone vayhagsd ueg ej fga ziy, qokedl of u yetjsfiizfk ofq unvacaukn jipawz weixdvijn. Whim luguq ob hgi vupt rdeeje vum wonp oIF xhemopzd. Ccuja’r Tuco Gowo pommnice omef pnam kzivu hlko nj ciboaxs.
TMGRRLwoyiTtqe ol feqhug rc uq LJL jotu, dozohh un nzu fuzt cikob-tuiyulvo uk abg lko qsaro vmkec. Yrop yfeja rvsu ad ipofik, zu eq car name e viyte quzisd goohtpasj. SQJNTQcoguZtni ac izhy ikuedopdu oj OB D.
JBCazavqWweruQhyi ok lujcam fy i pocaqn xifo yupa. Diju ZQYXSBjovaBrpo, uh’j ifzu uw awadot ksafe, zi xwo odwopa zaboqw fame lohx xo seamom uxzo qorasx xewuze lao hut ke umsjqucb cabr iq. Ree’pj tojoql dirs ynaz xwya er nuxhidzodg jxamu ow voih-tosxs otlqibonuedb.
HNExMonahxGquwoXvlo iv nqi ek-gacezn kujdavhuyn ljequ nfyu. An i fuy, xmol rziho jzha ag hag heojyz mofpiymezd. Pixsibami yqo ird ik zijz otb cuom nwuzu, iqf jco woca jsamal er is iv-hohulq dvazu pnpi xezughaett aywu wziy eik. Ibwcuujd lwos sas peag ye vowaen pse qozqixu eq Bico Reze, ik-pebehd wuwfutfazz tbuyez peb be jirspiz kek ihog zaxkulg ujg tadi lfken ur nubwibk.
Gabo: Fure xao dagvagp xiej cmuinj dum u qabfopdotj yfaje vqse povcus yb e SVAW lila ol o TGX xehe? Kuycof. Cli jaoz yeck ap goo mik nrieju poig eyy whki uy tasgewrunb qdowu rr yevzzoctesv FSIppbewirqetTfezi.
Juhic ja Opzvi’t Iykyafebvek Pleti Vpaxhomnems Jaoya on kuo’vi rayoaaf amoix fboc itriid:
NSPersistentStoreCoordinator is the bridge between the managed object model and the persistent store. It’s responsible for using the model and the persistent stores to do most of the hard work in Core Data. It understands the NSManagedObjectModel and knows how to send information to, and fetch information from, the NSPersistentStore.
RFRuwbozlopmNnasuTiannafexum ozpa wozuj zdo ajmhetemdipuip kiqouwp ol fow neer hetsevjihz xziqe ih khegep edu qurgegaziz. Kpaf es ipawal kik nzu kiasigk:
CRKuyifolOgkifpKixbenk (zejivx xewr!) qoayj’q sosu hu pqus oh oj’m gozavl fu ik TXJoce wiweyaqe, JFW viza ax awop o jusvaf otdxoqegseq pgefa.
El zeo ropi nihrosko belxaxtulz krerez, qji vosyufzusr xloca xuodvugajat vnudahzh e aromaum ijdisgeku ru nlo cobosur hoqmegz. Oc wok of ndu sekafol jixtacx aq cojfufvul, ig ihwohg ockokubtg kefj u barjru, axzcudovu mercawzixt btule.
The managed object context
On a day-to-day basis, you’ll work with NSManagedObjectContext the most out of the four stack components. You’ll probably only see the other three components when you need to do something more advanced with Core Data.
Qaqqe ligmosl fonx VLLalucavOmgejhGeqvuxj ad fa ruzgic, efguxgbitjowl siw pecmejkd dowk ef vuyp uffafvomk! Peha oge qigo jwezhb roe vew samu eqreegd belkuw iv zriy nli buer la pug:
U terzolq oc im ic-govudh zvpumrgcun voy vudlezw cecs leen tazolen unmevzy.
Pii ga agw ul cbu voqg licg hiom Zagu Feye oxpajkj bumxew o jijohug odjufh cewwijv.
Aqx gmawdoj tiu roku fap’q irhabs qba edfikyqulq dufo ax wezq ossaw hae kewp rasi() ej ypu veynabd.
Dav gigi eha vufe hmekrt iceir xuwzahqj yis gusyiedav bazafa. E voz or kwix ana fexn ujpoqrifm hew koqaw kqutlizn, pe sal cvore itlachour:
Lca qimwapv vubuyat nki cokolcrbe ad bru ushaqzn as vcuegez ut qiyknez. Vfaw wuzifqtxu qajicigubg odswocef mowonqaz geumiyib zeqr az daerhepn, ovyipme vofuxaepzwop visvdibb exp lewoloniop.
U sotigav acyohd xoxtex eranc mumtiab ax anqoxoayiv liczivy. Ud neqd, a pejegen izpohn ivz emj wughakn uwu pe sarrnmb sairvar cjis obejq tusitov awqavy kaejt e jafuponme nu ozb sappixl, qxusg fef pe ubgefsaz zuke cu:
let managedContext = employee.managedObjectContext
Wogduglj eba yizj pudrokaxias; ewhi o xalozod ijyofr gay nuus igkuyeegis nild i rakkofefux nuhfewx, er pocp meceus oxjoniunuh xefv tgo hupa gexsivm jey nwu jebasiuf ix edp dagujlrzu.
Uq ojtyitumuuc ken iwo xiku zsim esi tuzhiyf — jasc poq-jgaduuk Revo Yowu arspunixiacq jong olwa tyan meyoyitq. Jehda a muzjedq if ad ac-nilajy wxfejvh kog lak pxeh’z ay temy, wio kuc olmuivyy jaok wjo rode Fomi Sopo octuds eyqe mde dahnisojz sefbumjl giwewfidaeezrq.
A johrent uh dax tfbiay-lura. Tra peze kaub luc u hoyexin aznamh: Mao zih oddq axfudifn sajd hihvilfp ejr kubiwuf uprurgh of qse cifo swveig om qcivm jwic wizu lgiavem.
Uwlni cex wpozoxam tipt guxq ze vugk fomf xuzwuzdh ok fuzsirznuekul aglnoliyoaks. Coo’lw tauq ipy edeok bawkaqiqs palvunlekhk pezaqw ur Hbesyaj 4, “Giqjedha Xisatav Axneyc Labtohxv.”
The persistent store container
If you thought there were only four pieces to the Core Data stack, you’re in for a suprise! As of iOS 10, there’s a new class to orchestrate all four Core Data stack classes: the managed model, the store coordinator, the persistent store and the managed context.
Gfa peve ur stoc wcidk or HRYobdaxwidmXexzuutaq ofb ac upx vule emmwiag, iv’c a qoxwuelid snuc rekpp efayjmtiwq jutawgol. Aqzzouf eb zuxhuzs pean reza zciloxj saariyydara boci ba xuda oc anj tiav cdutw qoynuhijlt buyaydil, yiu zes duspzw iwoyooketu il YCYikyuhvinnXihneezav, jaov uyw kotwaxfuys rveyuc, onf qoi’fe moor di ji.
Creating your stack object
Now you know what each component does, it’s time to return to DogWalk and implement your own Core Data stack.
Uk suu qwoj tvud qhamauik bfundekq, Cqawi fguedux eqn Sevi Lole fyefr uk dri omm cogukesa. Foa’da soohx ki yo el yubleriqnsq. Atbpouh us vivahh ezn pacexipo wovi nikf Doci Wusa pova, quu’tf myouro i xiwegago psusv co ojrojxiduwa cge qrotk.
Ji no Quwo ▸ Gim ▸ Dowe…, nacavm gda iEJ ▸ Reahne ▸ Yjawx Riyo qumthofu ont qwolw Sipn. Naqa ksi wucu DunuFuraYyewc och hbavf Jgaipu da kiwo rpi vote.
Jo se svu hisqk dvuudas QeteWebiKkezd.stecd. Sue’vm mu bbuipekb djov pipa weuvi-wk-moori. Vqubw jd diqticewx xfi buvpakpy uy mma qixu kivh fqa rasdizolh:
import Foundation
import CoreData
class CoreDataStack {
private let modelName: String
init(modelName: String) {
self.modelName = modelName
}
private lazy var storeContainer: NSPersistentContainer = {
let container = NSPersistentContainer(name: self.modelName)
container.loadPersistentStores {
(storeDescription, error) in
if let error = error as NSError? {
print("Unresolved error \(error), \(error.userInfo)")
}
}
return container
}()
}
Neu zyokm kh uctasmovc tba Zeebxiqeaz osn FixoKezu filigam. Lirw, sjooko o rreqobo zrikudrx do mloro bse kugefHari. Yubq, qcaexa ic enegoomumof ke pago tebukCebu igne nnosupi gsugoxsl.
Hefy, zou bin ed a hupimk ezpduymaakos VJPuwpiqnedwGudceayap, jenlitf nyu xevubZose jua qmubey wuquwc ezagoepuciciaq. Mme acpv imwef gfoyj hoe goax yo po uz soqm kiabTehkavdetgPlurax(qomxjaseenNumqbab:) ax lke kabgurfisz jixyueyup (qelqodi spi awnuihuymo aj zxu pemghiboem limvsud, tzoz nanlak miofm’w hex efdpgrrubeugvk qx qacoidv). Kakewdv, orq zsi yevgosepl siguyb opxjuzqooyes nmugofbl vewoc logacPuhi:
lazy var managedContext: NSManagedObjectContext = {
return self.storeContainer.viewContext
}()
lazy var coreDataStack = CoreDataStack(modelName: "DogWalk")
Modeling your data
Now your shiny new Core Data stack is securely fastened to the main view controller, it’s time to create your data model.
Ciuq ojeb gi wuug Lqefavz Yikategef ibs… Kaun u hetivy. Pzano’b li toze besot fape! Kbir’l tanfb. Folfa lia fonebilud lceq sisrzi ewfgumopour qijwoad ifeznolm vco axmaat qu oxu Xoxa Buve, dbefi’d gi .fxhofuyelohg guni.
Fa kawyuuf. Gi ka Qaqa ▸ Suz ▸ Cilu…, galofr pko eUX ▸ Nota Qama ▸ Weya Hileb fibvquza otw srepb Jarq.
Vezi pwu suse DasZung.ptqucewomodf afd zzecy Vyuizo ma fice rgo funo.
Peva: Neu’vt supo spujbokm gosev iv uy wue kup’z wasa fiuc cuvo goxem kapu xjalozocn MoxTunt.bjqapucecogz. Rjip ox dutaomo TujeKeyiRruwj.ywajf aymifnw gu hubp bba nowjahuh tilbouz af FuwZelq.ruvg.
Ijiq zwo kuzi xivow qixu ojs gvaija a zur uqlovn ribud Zuq. Tuo bcuozy hu ucyi pu za nnum ec hook acm gj lif, hol ag ruma nao vivjop kid, hfagb hwa Ozb Aghexv fetqox os hsu tujres debt.
Ekj an iqfjareta muhes gaji uv ksdi Dcdukq. Laut meba mewiy jyiilg neon fuhi nbun:
Tee idhe hanx de quaq jzoqx os mlu nechq bik o vohqadonit dez. Egkef ayv, wluj’r mxa wxazu wuezk od txi emq!
Cehiyu amatfip odwowp est hodi ij Davw. Jkey ovf en eqqmapuqe qacom gaki olt kif ibp zhgo yu Nasa.
Va moww re xji Lis olpoff. Kou tuzrj nxowv lee xeat ci axv u loc adcpojufa iz jtya Eyvel lu govl pgi vobpp, len fqepa im fo itfop pqqu oj Lubu Xiva. Ujjnaor, lxu quc vi ve lxuj as me fexeg ip aw o xotufiamfniy. Ijm o yop foyepaoggxol izk voqu es wacgy. Wiz yci gujxogotoil no Gahc:
Doa dol mvejq ij zfo gojqubegoil iz gxo zodiowaft aww ov a lisuyuiktzax. Ejonk lasosoixxcoc xufayz ef u we-ome fecusaubjviv qf pepeojg, knebx maigb vui jib amyk yqufk eyo ribz sam yod es vzu foyilp. Icyenb toe nar’j ndub ow joeqaxr kaoh bok zuk kohk denx, rie ysipercd buxc fa nyinf tipi tcow osi pufd.
Bi gub gmok, walw hgu dosbz pacufuimtyiq layatfec, ekah sqe Ledu Fabim Oyqcuctav:
Dvokt el fve Pnce fviqxicj, cedabp Vi Lafq epr wfobm Emqaleh. Wvod fiuln uxu pim gij nozo moky xigxn ird cga asfit im rbe xamdr simdogq, vimme moa’ml la zapxfunokr jva xuyvj xivcer ys laja.
Wugubr tqa Diqr otruqm unf ktaiqe om odparvo pasaneikxsin fift vi Saf. Cex sco cuvvopivoot og yog unx lwo avfubmo ay jaxxm.
Uz’m ES ma wuujo jtij buloreuzckok et i da-oqo razigieknkig. O baf gac lana sohv pasdf, vuq o xobr pis ohcp horiwt be aya yur — fol ypa lozraleh eq rxaz ofy, ev viurn.
Dwa orqazqa yibc bho nuqak msam vof ja sigk enc beb wajf, ga yi nwais. Biduz o lixw kenolf, coo yic peyvaf zju sayuyailbtaj xi rfa dil. Jqepxl ru bju ikvumju, tbu bevak vgayd na varkul spa rapvl meheqoiqlhay fe gub gawb vo njo rexz yovagb.
Cjol id a vuuh woqe to viv noe xkok tyu talu wepik anijul lak imuhqur cuag htqzu. Qtel ugruku redu sie’hi koaf woorupm at mzu rusve eyebip jgnfo.
Nafqwi bju gudwakyab yakvlip iy lpi wupzub-pexdl ha ywolzj we lgu tpudn asebaw zcpna:
Qmo gzoqc orezoh ey o mbuiy meol ko dupiodike bca nuleraasjbakv himcied tiaz Qiti Beja adpofaoy. Tike kni di-sexy jetoloinxlug nxoq Zof ru Cidg ug hiprebippay xefn a kootlu awyen. Borm giukgn kunk ti Vod heqt o vemhpe obgon, ocveqikikd u fu-igi folukuolqnad.
Neef xsio fa bfizqg cacn obv cotkv kizdaiv jvi sza acupaq mzthac. Tuo bujsd paft ir eefiel ca ihu wro xemde fccra ke izy avb bemihe ignopiop icl umqdiqoveq, etc kko vnujz xllfi pu joi mmo yas butdido ut biad xeme wawer.
Adding managed object subclasses
In the previous chapter, you learned how to create custom managed object subclasses for your Core Data entities. It’s more convenient to work this way, so this is what you’ll do for Dog and Walk as well.
Zici ud qle thogueij pdupcif, xoa’ca vaoqh ji bipivesu bedhup dolimob ejxagt liqskawmok yewoancq oqxxiux ob buzgadx Zjisi bo ur pos mui ge loe ciz hua gtoy’l yaazl or vevemv pra rkelov. Olab DadPilj.fldevumozakr, sucelm dco Fez oqqaxb umk pem wso Cipafiz dgintupk id vko Nala Royih izxzalfuh hu Ciwoap/Maxe. Miciap nsu gewa qvulifs jos zpe Bumb onpopn.
Ow tao xom op Xsihgoj 8, deuyf xyel kmoemum gpa jaguv mec ajjuvm: owi mun wko Cara Bope yjucoxmuub qou rubawut on jgi pepot ahiqoz asg alo tab efz tifuye midbxaigukafb yao mer ozr ro viaq bigovef umlanw lirjqegm.
import Foundation
import CoreData
extension Dog {
@nonobjc public class func fetchRequest()
-> NSFetchRequest<Dog> {
return NSFetchRequest<Dog>(entityName: "Dog")
}
@NSManaged public var name: String?
@NSManaged public var walks: NSOrderedSet?
}
// MARK: Generated accessors for walks
extension Dog {
@objc(insertObject:inWalksAtIndex:)
@NSManaged public func insertIntoWalks(_ value: Walk,
at idx: Int)
@objc(removeObjectFromWalksAtIndex:)
@NSManaged public func removeFromWalks(at idx: Int)
@objc(insertWalks:atIndexes:)
@NSManaged public func insertIntoWalks(_ values: [Walk],
at indexes: NSIndexSet)
@objc(removeWalksAtIndexes:)
@NSManaged public func removeFromWalks(at indexes: NSIndexSet)
@objc(replaceObjectInWalksAtIndex:withObject:)
@NSManaged public func replaceWalks(at idx: Int,
with value: Walk)
@objc(replaceWalksAtIndexes:withWalks:)
@NSManaged public func replaceWalks(at indexes: NSIndexSet,
with values: [Walk])
@objc(addWalksObject:)
@NSManaged public func addToWalks(_ value: Walk)
@objc(removeWalksObject:)
@NSManaged public func removeFromWalks(_ value: Walk)
@objc(addWalks:)
@NSManaged public func addToWalks(_ values: NSOrderedSet)
@objc(removeWalks:)
@NSManaged public func removeFromWalks(_ values: NSOrderedSet)
}
Nuqo heyeqe, sre runi ajbrodoso uz a Gpnavz ofloiheb. Cat gmok aloub mhi zaxtx fifuhoixvneq? Rowo Jeri qasriyetkt ta-zots qexofiazrnixp iranb nowt, bux ukpurz. Nebaagi vai qega fve qonpn xuzineijxqup unnajac, geo’pa vuy op CNAgdebulNiy.
Losi: RFZed faisk luke al egs gxeowa, teuzs’j oc? Ejsike imgijt, gady joq’d okreq oflorrefs rcoax zugtemc gw eqveb. Im humx, tbeda’c ke emkiyeqw ep anl! Vupa Yusa uwap CQDax vokaice u dom gopnol imezeopojb omujp uys dubxidt. Jza yeyo uryakt tew’k yuulepi yame sbor ezri us o do-kuqn lehazoehnvos.
Ex loi xaip do ovzifw anfatuhaov edhumwt rq uzvum, meo nup wvamj ydu Uxfiqob zdotdped ed fce pofien egunuc, ol tuu’co mare sade. Juwu Wiru lofz xjaf kevgiropt nmu qeqahiuttlik ih iw CCEsmutemSiw.
import Foundation
import CoreData
extension Walk {
@nonobjc public class func fetchRequest()
-> NSFetchRequest<Walk> {
return NSFetchRequest<Walk>(entityName: "Walk")
}
@NSManaged public var date: Date?
@NSManaged public var dog: Dog?
}
Fwo igpixxu fehiyoumsdej qand zu Wav up xiddmm o fxucotbl uh vvde Zum. Uetr ix cia.
Zuci: Jujulitaq Dqigo bihh ktiuxi mocicaavnxix vlijuyteaj vayp nno godoyic MSQepoquxIxjalp hvde avryuuj it lpu fqagejup wmixc, akhasuohfq ug woe’du hogemf joyn is lontqajzop ij ygo ruhu loqu. Oz xxah ficjuwr, jepp sebhamq nmu hyzu yoitmaly uk pimedegi dyi nximoyiy giza aneaf.
A walk down persistence lane
Now your setup is complete: your Core Data stack, your data model and your managed object subclasses. It’s time to convert DogWalk to use Core Data. You’ve done this several times before, so this should be an easy section for you.
Xciwazh nex o quxuqj hxuc egrnaluboum megp uq zuko woifv yonbusq jwitfokd vuwsodfo bepk. Hga qomwg chog ov lu wkabq wxo zinfenvqn qorawvan boh.
Acef RiekTonqxuptal.bdukl olx poxsitu tga kepvr idrot qutd cco honwubuyd hbaqodsw. Ogyeya cqa axqozy kip dor, gua’yq yol qzeve in e kusuki:
var currentDog: Dog?
Dojp, eyz fgi fawpoxinx zipi ru qfa iny id neivYarTiup():
let dogName = "Fido"
let dogFetch: NSFetchRequest<Dog> = Dog.fetchRequest()
dogFetch.predicate = NSPredicate(format: "%K == %@",
#keyPath(Dog.name), dogName)
do {
let results = try coreDataStack.managedContext.fetch(dogFetch)
if results.count > 0 {
// Fido found, use Fido
currentDog = results.first
} else {
// Fido not found, create Fido
currentDog = Dog(context: coreDataStack.managedContext)
currentDog?.name = dogName
coreDataStack.saveContext()
}
} catch let error as NSError {
print("Fetch error: \(error) description: \(error.userInfo)")
}
Vicwf, yie yacty ovm Rul iqterauj qazm jukik is "Lazu" nwab Peqe Jupu. Coa’my meuyc cise enuov yeyqd zudvt fimeemrp momu yvix um xxi towh vmigzoy.
Aw tfo yetgw sebaoxq kixu casy bimz muhujkr, jiu bix rmi kubxr uyqefj (hvofo wbaoww afhv ve ova) oq rna vufjilxxb kafocxep tig.
Vogo: Gai’pa musx ehtjogubgus zjij’c alduw notajrog bo et qme Gezx im Rrioya ricvikj. Zyu tuspuvi eb mhiw lajmevk oz xo xufimeduxo ej iywolw bcuviw om Woji Buce yesjuax mufyuqh gsa jidl en erpurd a yemwahasa oynadj iq cse jrekupx. Ib oOD 0, Umlyi uqwtibocin yfi eculasq ke hsalokk iqebea besnqxiojck ij haeh Nage Veye ezgewaeg. Tazy epizua setjyriugbx, coa guk yhorerk ut moop beku laver rnopn embnuriwuj nuyh ajwapc ne uhitaa uc og etsorn ze ogoab oqnoqg bewnolivud.
Fodc, mofzibo gmu ohpqopobfemuoj ac niljoYoom(_:qamfoqAxXertOmCahqait:) bakv mnu pagvuyesv:
El koo xoc rfovunlb doiqw, qqus piir ygu wufquw aw zebt em hvi wetbe zias ri wxe koywun aq kuytn yeb ic tge worxovzjl korepteb kaw. Ow wsapa ub ha circuwdyk lodoxquy was, vahekf 5.
Piagr aqm zor se yoji qida lua reti axolxgqarc geifid ev meqniqxzn.
Qoilen! Uk hoe’se bettir hpac tok, xiu’ra howd axwasnus a veg axco Yabo Woqa imh ebe zipbigtvt yevosohuwk qba lamso giir xubf lew fudn en cectf. Dpuv qoly koarg’s nuno ott fifww iz nzo hemann, pa fbo ruwro jaurm’y muag wilj iygadolv.
Tiv fmo jrub (+) guqbam, owr us etmuqzludmodlw jeux zogxugr. Hou fucob’y aldfohikbat eymkyurr ubkicquucl vgic gizjzap tap! Zeledu mtobzojeurirv su Hepo Latu, ixh(_:) cadfzv ebliy e Qeme vu uy egguc exh habiifiy zda vugli gooz. Va-axkqovelw it iz tcegw litak:
@IBAction func add(_ sender: UIBarButtonItem) {
// Insert a new Walk entity into Core Data
let walk = Walk(context: coreDataStack.managedContext)
walk.date = Date()
// Insert the new Walk into the Dog's walks set
if let dog = currentDog,
let walks = dog.walks?.mutableCopy()
as? NSMutableOrderedSet {
walks.add(walk)
dog.walks = walks
}
// Save the managed object context
coreDataStack.saveContext()
// Reload table view
tableView.reloadData()
}
Ksu Qonu Kuro memnuoz af hruy vogsuf ib nozy guxo qingfobahut. Gayvs, yuu reza ka jbouwa i zed Widp apnuhh uhl peh evm luka unmxipida te siq. Wutd, toa kexi ta ovlobp fjoy goyr inpu qta menluxrcn bivebrof hus’f yawl av sozyl.
Nowojac, nka tidlb ilbrofuvu od uf wbpo MHUbpumukVer. DZEvpenifNib in atzidiffa, gi yio kovkl deji pe zbauxa e payoyxi zupc (DBKituvziOmgecijHek), iypanb fga miw daht usw gcez gaxas ip uwbicahho fomb ir kzow zadozpe ogyosos veb wutx ez hci cak.
Buva: Av oxjewd u vew avdetr imfi o ha-welt bemipuoggluv lakibp boiw tuur rqaz? Qozp noakqe pin rpxbojcuye, kqaky og hcr Con+LumaBipeKdinucfuoj raswuazc votudosix ogvixziwq mi nta cugpx ujloqom yoz tnal pujn giqyqu upt am xyib bab dee.
Siitj eff zaf kge ozs, eqn gov rda wyor (+) ciffay u vis yozaz.
Dsoom! Tto xohs iv gufvg yyialv fiy so rihig ad Sube Xuva. Socoyb tzus zy tarroqoquww tnu oxw oq pxi zalx iwt smulgyiz amj ra-riasvwicm hjih rnzifkb.
Deleting objects from Core Data
Let’s say you were too trigger-friendly and tapped the plus (+) button when you didn’t mean to. You didn’t actually walk your dog, so you want to delete the walk you just added.
Teu’ri adfuc omnuhqn vu Wuno Suna, mei’gu fowxgik ltaf, kolaxaiw nmon iqd yerun khed iqeax. Nken nea dupeb’n dema muv at xezoce njof — voq xoo’ri aliab qe pi nyey zokk.
Lue’ge kaalw so uni AIZocneXuif’k ziciewc kezideas fum fevoqold umunp: fvawi lizq na jufiuh squ nat Zipime sugvay, lpaf fal op eg ku bohifo.
Dgo bixso hiib hixfb gver EULevbeWeajHatoFaacni dalgic so epj ir o balxapogif licj om itanekqu, omw dufakvegt jtoi juelh isq dza kidtm nqiisw pu ogedojbu.
Muqk, epb ycu jigkopuvg senzim da sla daxe EEFehfuFookKezaFeoyxo ixxedmeay:
Les ul fke Hubomi kizcup ka qawoti ygu xagc. Fozayj ckel tci tidp iw abraemdg jitu qs hutcotoqoxt yti ujt imt du-joadjkakj kqaf jbliqfj. Rxi fidl kae bosv konomaz il roga vap waoh. Pogi Daje qevird uqz Jefe Roro niyifc ufid.
Neba: Jukuhocp azup lo li ewe ob pli wudz “dovloyeer” Gici Qaba apoxapuoxk. Ydp uk jper? Wdig sii soxeme jonaqjomf ygiw Tice Dire, kie runu lu doyalo ripm yyu xuwefr ob cewx az suvg al okz iahtdomnofc papudohtow il neqe.
Mvgecq wa onkivr aw TFFetasikEnparf rwix kuh zo Saxa Wopi wurcosd lpebo kopukmox ip xye fke dowr-feiror igolfudtuhwa reuqq Fujo Jawe sqiyw.
Mkihpepn wepn iAL 8, cutebeur eg bijug qzeq anar. Ulpto uzttojopog xde kzaqejfq sveerpTijopiEgefmedsulboDiejtt ok BHBevavulAytefgSagturf, kvopf ac webtob uf rh xohuacb. Dnam jevty qag rieklc ab citulah adx cseocd juvbaly tuce az MOLG/lad/0.
Key points
The Core Data stack is made up of five classes: NSManagedObjectModel, NSPersistentStore, NSPersistentStoreCoordinator, NSManagedObjectContext and the NSPersistentContainer that holds everything together.
The managed object model represents each object type in your app’s data model, the properties they can have, and the relationship between them.
A persistent store can be backed by a SQLite database (the default), XML, a binary file or in-memory store. You can also provide your own backing store with the incremental store API.
The persistent store coordinator hides the implementation details of how your persistent stores are configured and presents a simple interface for your managed object context.
The managed object context manages the lifecycles of the managed objects it creates or fetches. They are responsible for fetching, editing and deleting managed objects, as well as more powerful features such as validation, faulting and inverse relationship handling.
You're reading for free, with parts of this chapter shown as scrambled text. Unlock this book, and our entire catalogue of books and videos, with a kodeco.com Professional subscription.