Share
Core Data is een raamwerk dat Apple aan ontwikkelaars biedt en dat wordt omschreven als een "schemagericht objectgrafiekbeheer en persistentiekader." Wat betekent dat eigenlijk? Het framework beheert waar data wordt opgeslagen, hoe het wordt opgeslagen, datacaching en geheugenbeheer. Het werd geport naar de iPhone van Mac OS X met de 3.0 iPhone SDK-release.
In deze tutorial begeleid ik je bij het maken van een project met Core Data en laat je zien hoe je het kunt gebruiken met een eenvoudige UITableViewController. Het zal een eenvoudige database met één tabel zijn die de Lap Times zal opslaan en de tijden en hun gesplitste verschillen zal weergeven in een UITableView.
Voordat we aan de slag gaan, is het belangrijk om te begrijpen waarom u Core Data met SQLite wilt gebruiken voor opslag via eigenschappenlijsten, een aangepaste XML-indeling of directe SQLite-databasetoegang. Met de Core Data API kunnen ontwikkelaars een relationele database maken en gebruiken, recordvalidatie uitvoeren en query's uitvoeren met behulp van SQL-less-voorwaarden. Het stelt je in wezen in staat om te communiceren met SQLite in Objective-C en je geen zorgen te hoeven maken over verbindingen of het databaseschema te beheren, en de meeste van deze functies zijn bekend bij mensen die object-relationele mapping (ORM) technologieën hebben gebruikt zoals die in Ruby zijn geïmplementeerd op Rails, CakePHP, LINQ of andere bibliotheken en frameworks die de toegang tot de database abstraheren. Het belangrijkste voordeel van deze aanpak is dat het de ontwikkeltijd elimineert die anders nodig is om complexe SQL-query's te schrijven en de SQL handmatig af te handelen en deze bewerkingen uit te voeren.
De voorbeeldtoepassing die we vandaag gaan bouwen, is een eenvoudige rondetimer. Het maakt een nieuw record in de Core Data-winkel voor elke ronde die we maken. De UITableView toont dan het verschil tussen de huidige en de laatste ronde.
Om te beginnen zullen we XCode openen en een nieuw project maken. Noem het wat je wilt, ik heb het "LapTimer" genoemd. We zullen een "Window-gebaseerde applicatie" maken van de New Project-sjabloon selectie. Zorg ervoor dat "Gebruik kerngegevens voor opslag" is aangevinkt.
Het project zou bekend moeten zijn met wat je eerder hebt gezien als je eerder iPhone-applicaties hebt ontwikkeld.
Er hoeft niet veel te worden ingesteld omdat de optie 'Kerngegevens gebruiken voor opslag' in de sjabloon 'Op het venster gebaseerde toepassing' automatisch enkele belangrijke variabelen en gemaakte bestanden in het project voor ons heeft ingesteld.
In het LapTimer.xc datamodelbestand zullen we het schema voor onze SQLite-database definiëren. Het Core Data-raamwerk is ook aan het project toegevoegd om de bestanden voor API-toegang op te nemen. De andere wijzigingen worden aangebracht in de standaard toepassingsbestanden. In het bijzonder hebben de gedelegeerde bestanden van de toepassing de methoden om de Core Data store in onze applicatie in te stellen en te verwijzen naar het onderliggende UIViewControllers.
Waar we op dit moment in geïnteresseerd zijn, is het LapTimer.xcdatamodelbestand onder 'Resources'. Dit bestand geeft u een visuele kaart van uw schema met entiteiten en kenmerken.
Er zijn enkele verschillende termen en woordgroepen die in Core Data worden gebruikt en die losjes gerelateerd kunnen worden aan reguliere databasenamen, maar ze zijn niet identiek.
Een "entiteit", ook wel een "beheerd object" genoemd, is vergelijkbaar met een tabel. Het is een definitie van een object dat een verzameling gegevens bevat. Een entiteitobject bevat 'attributen'. Deze kunnen los worden gekoppeld aan kolommen, maar deze kenmerken zijn niet alleen beperkt tot gegevensopslag. Attributen kunnen een relatie tussen twee entiteiten definiëren, een dynamisch opgehaalde eigenschap of een eigenschap voor gegevensopslag definiëren.
Uit het bovenstaande diagram kunt u een idee krijgen van hoe flexibele objecten die zijn afgeleid van Core Data-entiteiten zijn. Voor deze voorbeeldtoepassing hebben we een heel eenvoudige entiteit nodig. We zullen de entiteit "Evenement" noemen, die de records van onze ronden zal opslaan.
Wat we zullen doen om deze entiteit te maken, is door op de knop [+] te klikken in de eerste kolom (van links) bovenaan. Hiermee wordt een nieuwe entiteit in de lijst gemaakt en visueel op de schema-indeling onder de kolommen.
Dit is een mooie visuele editor voor je model. Core Data doet echt het zware werk als het gaat om het "M" (Model) deel van MVC. De visuele editor toont de relaties, eigenschappen en entiteiten van de winkel terwijl het schema dynamisch voor u wordt gemaakt en beheerd. Dit is vergelijkbaar met Interface Builder, omdat het zorgt voor de toewijzing, het beheer en het plaatsen van objecten voor u op een UIView zonder een enkele regel code.
Met de nieuwe gebeurtenis-entiteit op zijn plaats, willen we een 'eigenschap' maken. Aangezien deze eigenschap gegevens opslaat, zullen we deze als een 'kenmerk' instellen. Dus dit nieuwe attribuut slaat alleen de huidige datum op voor het moment waarop het record werd aangemaakt. In onze voorbeeldtoepassing gebruiken we dit om naar onze rondetijden te verwijzen.
De volgende kolom aan de rechterkant is waar we onze eigenschappen definiëren (zorg ervoor dat de entiteit Gebeurtenis is geselecteerd). Maak dus een nieuwe eigenschap met de knop [+] in de kolom, selecteer 'Attribuut toevoegen'.
We zullen het attribuut "timeStamp" roepen en het Type op "Datum" zetten. In de vervolgkeuzelijst Type selecteren zijn er vergelijkbare kolomgegevenstypen als diegene die beschikbaar zijn in relationele databasesystemen zoals PostgreSQL of MySQL, inclusief gegevenstypen zoals gehele getallen, drijvers, tekenreeksen, booleans, datums en binaire gegevens (blobs).
Voor dit kenmerk hebben we geen andere opties nodig die zijn geselecteerd of gewijzigd.
Dat is het voor het xcdatamodel-bestand, en we kunnen doorgaan om het in onze app te integreren. Dit is een goed moment om je werk te bewaren.
Als u een MVC-raamwerk hebt gebruikt met definities van databasemodellen die de structuur of het gedrag van een tabel definiëren, dan is dit een bekende taak.
We moeten beginnen door een definitie van de entiteit te maken. We doen dit door een NSManagedObject-klasse van de entiteit te maken en de variabelen te definiëren die de store heeft.
Dit is een eenvoudig proces. Selecteer de gebeurtenisentiteit in het LapTimer.xc datamodelbestand en ga naar Bestand> Nieuw bestand. U zult zien dat er een nieuwe bestandssjabloon is in de sectie "Cocoa Touch Class" genaamd "Beheerde Objectklasse".
Selecteer de sjabloon en klik op "Volgende". Het volgende scherm definieert alleen waar we het bestand opslaan en het doel om het mee te nemen, dit is allemaal standaard correct dus klik opnieuw op "Volgende". In het volgende scherm definieert u voor welke entiteiten u NSManagedObject-klassen wilt maken. Als dit niet is geselecteerd, selecteert u Gebeurtenis en zorgt u ervoor dat de selectievakjes "Generate Accessors" en "Generate Obj-C 2.0 properties" zijn geselecteerd. We hebben op dit moment geen validaties nodig. Klik op Finish.
Dus nu hebben we 2 nieuwe bestanden in onze applicatie. Event.m en Event.h. Ze definiëren de klasse NSManagedObject voor de gebeurtenisentiteit die we hebben gemaakt in onze Core Data Store. Ze definiëren het veld timeStamp, dus wanneer we de klasse Event willen gebruiken, hebben we toegang tot het kenmerk.
Event.h
#importeren@interface Event: NSManagedObject @property (nonatomic, retain) NSDate * timeStamp; @einde
Event.m
#import "Event.h" @implementation Event @dynamic timeStamp; @einde
Net als modeldefinities in andere kaders en talen kunt u aangepaste methoden toevoegen voor alle records in de gebeurtenisentiteit. U zult opmerken dat het timeStamp-kenmerk is toegevoegd en toegewezen als een NSDate-object.
Met Core Data-instellingen is het nu tijd om aan een deel van de logica van de controller in de applicatie te werken. We gebruiken een UITableViewController als de belangrijkste interface van de app om de rondetijden weer te geven en een nieuwe tijd aan te melden.
Dus we zullen de nieuwe UITableViewController maken met Bestand> Nieuw Bestand. Selecteer vervolgens onder de iPhone-sectie "UIViewController subklasse" en vink "UITableViewController subklasse" aan, maar schakel geen vakjes in die betrekking hebben op het gebruik van XIB's of voor het richten op een iPad. We zullen geen XIB gebruiken voor deze controller. Roep het nieuwe bestand "TimeTableController" aan en voltooi de bestandswizard.
In deze controller hebben we 2 eigenschappen nodig, een verwijzing naar de NSManagedObjectContext en een array om de records op te slaan voor de UITableView. Naast het definiëren van die eigenschappen, zullen we het Event.h-bestand importeren, zodat we de klasse kunnen gebruiken.
TimeTableController.h
#importeren#import "Event.h" @interface TimeTableController: UITableViewController NSManagedObjectContext * managedObjectContext; NSMutableArray * eventArray; @property (nonatomic, retain) NSManagedObjectContext * managedObjectContext; @property (nonatomic, retain) NSMutableArray * eventArray; - (ongeldig) fetchRecords; - (void) addTime: (id) afzender; @einde
Wat is een NSManagedObjectContext? Het wordt het "scratchpad" genoemd voor basisgegevens in de toepassing voor het beheren van het ophalen, bijwerken en maken van records in de winkel. Het beheert ook enkele fundamentele functies in Core Data, inclusief validaties en ongedaan maken / opnieuw beheren voor de records.
De context van het beheerde object is de verbinding tussen uw code en de gegevensopslag. Alle bewerkingen die u uitvoert voor Core Data doen dit tegen de context van het beheerde object. Wanneer een aanvraag wordt uitgevoerd, zal de context van het beheerde object praten met de persistente winkelcoördinator die verantwoordelijk is voor het toewijzen van de objecten aan gegevens voor de gegevensopslag. Hierdoor kunnen de kerngegevens flexibel zijn tussen verschillende gegevensopslagformaten. Hier is een diagram van hoe dit eruit ziet.
Als het header-bestand is gedefinieerd, moeten we de toegewezen eigenschappen en methoden in het implementatiebestand doorgeven.
TimeTableController.m
#import "TimeTableController.h" @implementation TimeTableController @synthesize managedObjectContext, eventArray; // ... // ... standaard commentaarcode uit de bestandssjabloon // ... - (void) viewDidLoad [super viewDidLoad]; self.title = @ "Rondetijden"; UIBarButtonItem * addButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem: UIBarButtonSystemItemAdd target: self action: @selector (addTime :)]; self.navigationItem.rightBarButtonItem = addButton; [addButton release]; [self fetchRecords]; - (void) addTime: (id) afzender Event * event = (Event *) [NSEntityDescription insertNewObjectForEntityForName: @ "Event" inManagedObjectContext: managedObjectContext]; [event setTimeStamp: [NSDate date]]; NSError * -fout; if (! [managedObjectContext save: & error]) // Dit is een ernstige fout met de melding dat de record // niet kon worden opgeslagen. Adviseer de gebruiker om // opnieuw te proberen of de toepassing opnieuw te starten. [eventArray insertObject: event atIndex: 0]; [self.tableBekijk reloadData]; - (void) fetchRecords // Definieer onze tabel / entiteit om NSEntityDescription * entity = [NSEntityDescription entityForName: @ "Event" inManagedObjectContext: managedObjectContext] te gebruiken; // Stel de ophaalopdracht in NSFetchRequest * request = [[NSFetchRequest alloc] init]; [request setEntity: entity]; // Definieer hoe we de records sorteren NSSortDescriptor * sortDescriptor = [[NSSortDescriptor alloc] initWithKey: @ "timeStamp" oplopend: NEE]; NSArray * sortDescriptors = [NSArray arrayWithObject: sortDescriptor]; [request setSortDescriptors: sortDescriptors]; [sortDescriptor release]; // De records ophalen en een fout NSError * verwerken; NSMutableArray * mutableFetchResults = [[managedObjectContext executeFetchRequest: request error: & error] mutableCopy]; if (! mutableFetchResults) // Omgaan met de fout. // Dit is een ernstige fout en moet de gebruiker adviseren om de toepassing opnieuw te starten // Sla onze opgehaalde gegevens op in een array [self setEventArray: mutableFetchResults]; [mutableFetchResults release]; [verzoek vrijgave]; // ... // ... meer sjablooncommentaar en standaardmethode-definities // ... - (void) dealloc [managedObjectContext release]; [release eventArray]; [super dealloc]; @end
Dat is een aardig stukje code, dus laat het elke methode afzonderlijk doorlopen. Er is een code vanaf wanneer je het bestand uit de sjabloon hebt gemaakt, commentaar hebt gegeven op methoden zoals viewDidUnload, die ik zojuist heb weggelaten uit het bovenstaande.
We beginnen met de gebruikelijke oproep aan de superklasse. Vervolgens definiëren we de titel van de UINavigationBar. Daarna moeten we de knop definiëren die we zullen gebruiken om een record toe te voegen aan de Core Data Store. Wanneer de knop wordt ingedrukt, zeggen we dat deze de selector addTime moet aanroepen: die zal dan communiceren met Core Data. Na de vereiste releases kunnen we de fetchRecords-functie aanroepen, die hieronder wordt uitgelegd.
Deze wordt geactiveerd wanneer op het UIBarButtonItem rechtsboven op de UINavigationBar wordt gedrukt. We moeten een nieuw evenementrecord maken met de huidige NSDate en opslaan in de database.
We maken een nieuw evenementrecord dat een NSEntityDescription wordt genoemd. Dit is uw rij in de database voor het nieuwe record. Hiertoe definiëren we de entiteitnaam waartoe de record behoort en bieden we de NSManagedObjectContext. De huidige datum wordt dan ingesteld tegen het timeStamp-attribuut.
De opslagbewerking wordt dan uitgevoerd, maar er is een voorziening om een fout af te handelen als de invoeging mislukt. Normaal gesproken gooi je een UIAlertView-bericht dat de record niet heeft aangemaakt en misschien geeft het de gebruiker de opdracht om het opnieuw te proberen of de toepassing te sluiten en opnieuw te openen.
Het record moet worden toegevoegd aan de array waaruit de UITableView feeds is. Vervolgens moet de UITableView worden verteld om de gegevens opnieuw te laden. U kunt dit grafischer doen met een animatie, maar omwille van de zelfstudie houden we het eenvoudig.
Deze methode haalt de gegevens uit de winkel en voegt deze toe aan de array die we in de controller hebben. Voor meer informatie over het verkrijgen van gegevens, laten we NSFetchRequest van naderbij bekijken.
Core Data heeft een andere benadering voor het ophalen van gegevens uit de database. Het is een NoSQL data store, wat betekent dat alle voorwaarden van een query gebaseerd zijn op methoden. Dit is geweldig omdat het basisarchief, dat SQLite is, kan worden gewijzigd in elke andere databasetechnologie en het enige dat moet worden gewijzigd, is de verbinding en stuurprogramma's voor de database..
Voor het maken van een aanvraag maken we dus een NSFetchRequest-object. Dit is het basisobject waarop de queryvoorwaarden worden ingesteld. We kunnen voorwaarden definiëren voor het matchen van een bepaalde eigenschap op basis van hoe records worden gerangschikt. U kunt meer informatie vinden over kerngegevens en de voorwaarden voor NSFetchRequests in hun documentatie.
Het maken van een nieuwe NSFetch-aanvraag is eenvoudig. U hoeft alleen de entiteit te definiëren waarvan u records wilt en de NSManagedObjectContext.
NSEntityDescription * entity = [NSEntityDescription entityForName: @ "Event" inManagedObjectContext: managedObjectContext]; NSFetchRequest * request = [[NSFetchRequest alloc] init]; [request setEntity: entity];
De entiteit wordt gedefinieerd met behulp van een NSEntityDescription-object dat de entiteitsnaam en de NSManagedObjectContext vereist. Het ophaalverzoek wordt vervolgens gemaakt en geeft de entiteitbeschrijving door. Dit zou gelijk zijn aan het eerste deel van een SQL-statement:
SELECT * FROM 'evenementen'
In onze voorbeeldtoepassing sorteren we de gegevens door de timeStamp op een dalende manier. Om dit te doen gebruiken we een NSSortDescriptor.
NSSortDescriptor * sortDescriptor = [[NSSortDescriptor alloc] initWithKey: @ "timeStamp" oplopend: NEE]; NSArray * sortDescriptors = [NSArray arrayWithObject: sortDescriptor]; [request setSortDescriptors: sortDescriptors]; [sortDescriptor release];
De NSSortDescriptor is gemaakt en we definiëren het attribuut dat we willen sorteren en of het stijgt, in dit geval willen we dat het naar beneden gaat, dus het is ingesteld op NO. Het ophaalverzoek kan vele sorteerbeschrijvingen aannemen, zodat het een array accepteert bij het instellen van de sorteerbeschrijvingen. Omdat we er slechts één willen, hoeven we alleen maar een array te maken met één object erin. We stellen de descriptorarray in tegen het ophaalverzoek en dat is dat.
Voor het definiëren van een voorwaarde om overeen te komen met de inhoud van een record komt de klasse NSPredicate in het spel. Hiermee kan het ophaalverzoek overeenkomen of een bereik definiëren waaraan de inhoud van een record moet voldoen. Dit is het equivalent van uw gelijken, groter en kleiner dan overeenkomsten in SQL. Het heeft meer dan uw standaard SQL-functies, die u hier kunt zien.
Het instellen van een predikaat kan heel eenvoudig zijn.
NSPredicate * predicate = [NSPredicate predicateWithFormat: @ "(lastName like% @) AND (birthday>% @)", lastNameSearchString, birthdaySearchDate];
NSPredicate predicateWithFormat gebruiken: is een eenvoudige en vertrouwde methode waarmee u de voorwaarden van de query kunt definiëren. Voor een uitgebreide uitleg over NSPredicates heeft de Apple-documentatie enkele geweldige richtlijnen.
Wanneer u de voorwaarden in uw ophaalopdracht hebt gedefinieerd, kunt u deze uitvoeren.
NSMutableArray * mutableFetchResults = [[managedObjectContext executeFetchRequest: request error: & error] mutableCopy];
Dat retourneert een array met entiteitobjecten, NSManagedObjects, om te gebruiken in uw gegevensuitvoer.
Met de gegevens opgehaald uit Core Data en opgeslagen in de eventArray kunnen we die records nu uitvoeren naar de UITableView.
Het eerste is om aan de tafel te vertellen dat we slechts 1 sectie nodig hebben en hoeveel rijen we moeten gebruiken.
Fragment van TimeTableController.m
-(NSInteger) numberOfSectionsInTableView: (UITableView *) tableView return 1; - (NSInteger) tableView: (UITableView *) tableView numberOfRowsInSection: (NSInteger) sectie return [eventArray-telling];
Als je eerder een UITableViewController hebt gebruikt, zou de volgende functie rechttoe rechtaan moeten zijn.
-(UITableViewCell *) tableView: (UITableView *) tableView cellForRowAtIndexPath: (NSIndexPath *) indexPath static NSString * CellIdentifier = @ "Cell"; static NSDateFormatter * dateFormatter = nil; if (dateFormatter == nil) dateFormatter = [[NSDateFormatter alloc] init]; [dateFormatter setDateFormat: @ "h: mm.ss a"]; UITableViewCell * cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier]; if (cell == nil) cell = [[[UITableViewCell alloc] initWithStyle: UITableViewCellStyleValue1 reuseIdentifier: CellIdentifier] autorelease]; Event * event = [eventArray-objectAtIndex: [rij indexPath]]; Evenement * previousEvent = nihil; if ([eventArray-telling]> ([indexPath-rij] + 1)) previousEvent = [eventArray-objectAtIndex: (rij [indexPath] + 1)]; [cell.textLabel setText: [dateFormatter stringFromDate: [event timeStamp]]]; if (previousEvent) NSTimeInterval timeDifference = [[event timeStamp] timeIntervalSinceDate: [previousEvent timeStamp]]; [cell.detailTextLabel setText: [NSString stringWithFormat: @ "+%. 02f sec", timeDifference]]; else [cell.detailTextLabel setText: @ "---"]; return cel;
De cel geeft 2 waarden weer, van de UITableViewCellStyleValue1-stijl. Links is de tijd van de ronde en rechts is het verschil in seconden van het vorige record.
Aangezien deze methode itereert, moeten we extra voorzichtig zijn met de belasting die het apparaat kan gebruiken als het niet goed wordt beheerd. Om die reden wordt de NSDatFormatter opgeslagen als een statische variabele, zodat deze in elke iteratie opnieuw kan worden gebruikt zonder deze telkens toe te wijzen en vrij te geven.
Lazy Loading is een techniek waarbij u het verzoek of de toewijzing van een woning zo veel mogelijk uitstelt. Dit helpt het geheugen laag te houden en tijdens iteratieve functies is dit van het grootste belang. Weten wanneer en hoe u gegevens moet toewijzen, is cruciaal om een mobiele app snel te houden. Deallocatie van het object is ook zo belangrijk, hoe eerder hoe beter.
cellForRowAtIndexPath: is een iteratieve methode en alle gegevens die in deze methode worden verwerkt of toegewezen, moeten met name tot een minimum worden beperkt. Deze methode wordt uitgevoerd wanneer een cel in beeld komt, dus wanneer een gebruiker snel scrolt, kan deze specifieke methode, afhankelijk van de recordsetgrootte, heel vaak achter elkaar worden aangeroepen.
De volgende taak is om het gebeurtenisobject te koppelen aan de tabelrij die moet worden weergegeven. Aangezien we het vorige record voor de tijdvergelijking moeten krijgen, is er een eenvoudige controle om te zien of er een vorige record is en om het op te slaan in previousEvent. Als het vorigeEvent bestaat, berekenen we de splitsing met behulp van [NSDate timeIntervalSinceDate: (NSDate)]. Het tekstlabel en het gedetailleerde tekstlabel worden vervolgens ingesteld met de waarden die we hebben berekend.
Met de UITableViewController-opstelling en de tabelgegevensbron die werkt met de Core Data-store, hoeft alleen de controller te worden geladen wanneer de toepassing wordt gestart.
In de toepassingscontroller moet een UINavigationController-eigenschap worden gedefinieerd. Dan moet de applicationDidFinishLaunching-methode alleen de controller toewijzen en zijn we klaar.
LapTimerAppDelegate.h
@interface LapTimerAppDelegate: NSObjectNSManagedObjectModel * managedObjectModel; NSManagedObjectContext * managedObjectContext; NSPersistentStoreCoordinator * persistentStoreCoordinator; UIWindow * venster; UINavigationController * navigationController; @property (nonatomic, retain, readonly) NSManagedObjectModel * managedObjectModel; @property (nonatomic, retain, readonly) NSManagedObjectContext * managedObjectContext; @property (nonatomic, retain, readonly) NSPersistentStoreCoordinator * persistentStoreCoordinator; @property (nonatomic, retain) IBOutlet UIWindow * venster; @property (nonatomic, retain) UINavigationController * navigationController; - (NSString *) applicationDocumentsDirectory; @einde
Fragment van LapTimerAppDelegate.m
#import "LapTimerAppDelegate.h" #import "TimeTableController.h" @implementation LapTimerAppDelegate @synthesize window, navigationController; - (void) applicationDidFinishLaunching: (UIApplication *) applicatie TimeTableController * tableController = [[TimeTableController alloc] initWithStyle: UITableViewStylePlain]; tableController.managedObjectContext = [self managedObjectContext]; self.navigationController = [[UINavigationController alloc] initWithRootViewController: tableController]; [tableController release]; [window addSubview: [view zelfnavigatieController]]; [window makeKeyAndVisible]; // ... // ... andere sjabloonmethoden // ... - (void) dealloc [managedObjectContext release]; [managedObjectModel release]; [persistentStoreCoordinator release]; [venster vrijgeven]; [navigationController release]; [super dealloc];
Het bestand TimeTableController.h wordt opgenomen in de toepassingsdeelnemer en vervolgens toegewezen aan een UINavigationController.
Dat zou het moeten zijn. Bouw de applicatie om te controleren op fouten. Sommige codevoorbeelden zijn slechts uittreksels, geen van de code die wordt gegenereerd bij het maken van een bestand is verwijderd, alleen ingevuld. Als er fouten optreden die u niet kunt kraken, kunt u het projectbestand downloaden dat bij deze zelfstudie hoort welke je dan kunt compileren en vergelijken.
Start de applicatie. U ziet de navigatiecontroller en de knop Toevoegen. Druk op de knop Toevoegen en u krijgt een nieuwe tijd in de tabel.
In deze zelfstudie hebben we een voorbeeldtoepassing gemaakt om eenvoudige gegevens op te slaan in een kerngegevensarchief. De applicatie doorloopt de initiële instellingsprocedure bij het maken van een applicatie met Core Data, het definiëren van de datastructuur en het ophalen van records uit de datastore.
Hopelijk hebt u kennisgemaakt met Core Data en kunt u zien hoe eenvoudig het is om te gebruiken en hoe het de prestaties en functionaliteit van uw applicaties kan verbeteren..
Als u meer wilt weten over Core Data of een gedetailleerd overzicht wilt hebben van de structuur van het framework, dan is de Apple Developer Documentation de perfecte plaats om naartoe te gaan.
Apple Developer Documentation:
Inleiding tot kerngegevensprogrammering
Core Data Migration en Versioning
NSPredicate programmeerhandleiding:
Accentsconagua