Share
Core Data ist ein Framework, das Apple Entwicklern zur Verfügung stellt und als "Schema-gesteuertes Objektgraph-Management- und Persistenz-Framework" bezeichnet wird. Was heißt das eigentlich? Das Framework verwaltet, wo Daten gespeichert werden, wie sie gespeichert werden, wie Daten zwischengespeichert werden und wie Speicherverwaltung erfolgt. Mit der Version 3.0 iPhone SDK wurde es von Mac OS X auf das iPhone portiert.
In diesem Tutorial werde ich Sie durch den Prozess der Erstellung eines Projekts mit Core Data führen und Ihnen zeigen, wie Sie es mit einem einfachen UITableViewController verwenden können. Es wird eine einfache Ein-Tabellen-Datenbank sein, in der die Lap Times gespeichert wird und die Zeiten und ihre Aufteilungsunterschiede in einer UITableView angezeigt werden.
Bevor wir beginnen, ist es wichtig zu verstehen, warum Sie Core Data mit SQLite verwenden möchten, um über Eigenschaftslisten, ein benutzerdefiniertes XML-Format oder den direkten Zugriff auf die SQLite-Datenbank zu speichern. Mit der Core Data-API können Entwickler eine relationale Datenbank erstellen und verwenden, die Überprüfung der Datensätze durchführen und Abfragen unter Verwendung von Bedingungen ohne SQL durchführen. Im Wesentlichen können Sie in Objective-C mit SQLite interagieren und müssen sich keine Gedanken um Verbindungen oder die Verwaltung des Datenbankschemas machen. Die meisten dieser Funktionen sind für Personen bekannt, die ORM-Technologien (Object Relational Mapping) wie die in Ruby implementierten Technologien verwendet haben auf Rails, CakePHP, LINQ oder anderen Bibliotheken und Frameworks, die den Zugriff auf die Datenbank abstrahieren. Der Hauptvorteil dieses Ansatzes besteht darin, dass die Entwicklungszeit entfällt, die sonst zum Schreiben komplexer SQL-Abfragen und zur manuellen Verarbeitung der SQL-Anweisungen und der Ausgabe dieser Operationen erforderlich ist.
Die Beispielanwendung, die wir heute erstellen werden, ist ein einfacher Lap-Timer. Für jede Runde, die wir machen, wird ein neuer Datensatz im Core Data Store erstellt. Die UITableView zeigt dann die Differenz zwischen der aktuellen und der letzten Runde an.
Zum Einstieg öffnen wir XCode und erstellen ein neues Projekt. Nennen Sie es, wie Sie es wünschen, ich habe es "LapTimer" genannt. Wir erstellen eine "fensterbasierte Anwendung" aus der Auswahl "Neues Projekt". Stellen Sie sicher, dass "Core Data for Storage" verwendet wird.
Das Projekt sollte mit dem vertraut sein, was Sie zuvor gesehen haben, wenn Sie zuvor iPhone-Anwendungen entwickelt haben.
Es gibt nicht viele Einstellungen, da die Option "Use Core Data for Storage" in der Vorlage "Window-based Application" automatisch einige wichtige Variablen festgelegt und Dateien im Projekt für uns erstellt hat.
In der Datei LapTimer.xcdatamodel definieren wir das Schema für unsere SQLite-Datenbank. Das Core Data-Framework wurde dem Projekt auch hinzugefügt, um die Dateien für den API-Zugriff einzuschließen. Die anderen Änderungen werden in den Standardanwendungsdateien vorgenommen. Insbesondere verfügen die Anwendungsdelegatendateien über die Methoden, den Core Data Store in unserer Anwendung einzurichten und in untergeordneten UIViewControllern darauf zu verweisen.
Was uns im Moment interessiert, ist die LapTimer.xcdatamodel-Datei unter "Ressourcen". Diese Datei enthält eine visuelle Karte Ihres Schemas mit Entitäten und Attributen.
In Core Data werden verschiedene Ausdrücke und Ausdrücke verwendet, die lose mit regulären Datenbanknamen zusammenhängen, aber nicht identisch sind.
Eine "Entität", auch "verwaltetes Objekt" genannt, ähnelt einer Tabelle. Dies ist die Definition eines Objekts, das eine Sammlung von Daten enthalten wird. Ein Entitätsobjekt enthält "Attribute". Diese können lose mit Spalten verknüpft werden, aber diese Attribute sind nicht nur auf die Datenspeicherung beschränkt. Attribute können eine Beziehung zwischen zwei Entitäten, eine dynamisch abgerufene Eigenschaft oder eine Eigenschaft für die Datenspeicherung definieren.
Im obigen Diagramm können Sie ein Gefühl dafür bekommen, wie flexibel Objekte sind, die von Core Data-Entitäten stammen. Für diese Beispielanwendung benötigen wir eine wirklich einfache Entität. Wir nennen die Entität "Ereignis", in der Aufzeichnungen unserer Runden gespeichert werden.
Um dieses Objekt zu erstellen, klicken Sie auf die Schaltfläche [+] in der ersten (von der linken) oberen Spalte. Dadurch wird eine neue Entität in der Liste und visuell in der Schemazuordnung unterhalb der Spalten erstellt.
Dies ist ein schöner visueller Editor für Ihr Modell. Core Data macht das schwere Heben wirklich, wenn es um den "M" (Model) Teil von MVC geht. Der visuelle Editor zeigt die Beziehungen, Eigenschaften und Entitäten des Speichers an, während das Schema dynamisch für Sie erstellt und verwaltet wird. Dies ähnelt dem Interface Builder, da er die Zuweisung, Verwaltung und Platzierung von Objekten in einer UIView ohne eine einzige Codezeile übernimmt.
Mit der neuen Ereignisentität möchten wir eine "Eigenschaft" erstellen. Da diese Eigenschaft Daten speichert, werden wir sie als "Attribut" festlegen. Dieses neue Attribut speichert also nur das aktuelle Datum, an dem der Datensatz erstellt wurde. In unserer Beispielanwendung beziehen wir uns auf unsere Rundenzeiten.
In der nächsten Spalte rechts definieren wir unsere Eigenschaften (stellen Sie sicher, dass die Ereignisentität ausgewählt ist). Erstellen Sie also eine neue Eigenschaft mit der Schaltfläche [+] in der Spalte und wählen Sie "Attribut hinzufügen"..
Wir werden das Attribut "timeStamp" nennen und den Typ auf "Date" setzen. In der Dropdown-Liste Typauswahl gibt es ähnliche Spaltendatentypen wie in relationalen Datenbanksystemen wie PostgreSQL oder MySQL, einschließlich Datentypen wie Ganzzahlen, Gleitkommazahlen, Zeichenfolgen, Boolesche Daten, Datumsangaben und Binärdaten (Blobs).
Für dieses Attribut müssen keine weiteren Optionen ausgewählt oder geändert werden.
Das ist es für die xcdatamodel-Datei, und wir können sie in unsere App integrieren. Jetzt ist ein guter Zeitpunkt, um Ihre Arbeit zu retten.
Wenn Sie ein MVC-Framework mit Datenbankmodelldefinitionen verwendet haben, die die Struktur oder das Verhalten einer Tabelle definieren, ist dies eine vertraute Aufgabe.
Wir müssen zunächst eine Definition der Entität erstellen. Dazu erstellen wir eine NSManagedObject-Klasse der Entität und definieren die Variablen, die der Speicher besitzt.
Dies ist ein einfacher Prozess. Wählen Sie die Ereignisentität in der Datei LapTimer.xcdatamodel aus und wählen Sie Datei> Neue Datei. Sie werden sehen, dass sich im Abschnitt "Cocoa Touch Class" eine neue Dateivorlage mit dem Namen "Managed Object Class" befindet..
Wählen Sie die Vorlage aus und klicken Sie auf "Weiter". Der nächste Bildschirm definiert nur, wo wir die Datei speichern und das Ziel, in das sie eingefügt werden sollen. Dies ist standardmäßig korrekt, also klicken Sie erneut auf "Weiter". Im nächsten Bildschirm definieren Sie, für welche Entitäten Sie NSManagedObject-Klassen erstellen möchten. Wenn es nicht ausgewählt ist, wählen Sie Event aus und stellen Sie sicher, dass die Kontrollkästchen "Accessors generieren" und "Obj-C 2.0-Eigenschaften generieren" aktiviert sind. Wir benötigen zurzeit keine Validierungen. Klicken Sie auf "Fertig stellen".
Jetzt haben wir 2 neue Dateien in unserer Anwendung. Event.m und Event.h. Sie definieren die NSManagedObject-Klasse für die Ereignisentität, die wir in unserem Core Data Store erstellt haben. Sie definieren das Feld timeStamp, sodass wir auf das Attribut zugreifen können, wenn wir die Event-Klasse verwenden möchten.
Event.h
#einführen@interface Ereignis: NSManagedObject @property (nicht atomar, beibehalten) NSDate * timeStamp; @Ende
Event.m
#import "Event.h" @implementation Event @dynamic timeStamp; @Ende
Wie Modelldefinitionen in anderen Frameworks und Sprachen können Sie benutzerdefinierte Methoden für alle Datensätze in der Ereignisentität hinzufügen. Sie werden feststellen, dass das timeStamp-Attribut hinzugefügt und als NSDate-Objekt zugewiesen wurde.
Mit dem Core Data-Setup ist es jetzt an der Zeit, einige Steuerungslogiken in der Anwendung zu bearbeiten. Wir verwenden einen UITableViewController als Hauptschnittstelle der App, um die Rundenzeiten anzuzeigen und eine neue Zeit zu protokollieren.
Wir erstellen also den neuen UITableViewController mit Datei> Neue Datei. Wählen Sie dann im Abschnitt "iPhone" die Option "UIViewController-Unterklasse" aus und aktivieren Sie die Option "UITableViewController-Unterklasse", jedoch keine Kontrollkästchen, die sich auf die Verwendung von XIBs oder das Targeting für ein iPad beziehen. Wir werden keine XIB für diesen Controller verwenden. Rufen Sie die neue Datei "TimeTableController" auf und beenden Sie den Datei-Assistenten.
In diesem Controller benötigen wir 2 Eigenschaften, einen Verweis auf den NSManagedObjectContext und ein Array, in dem die Datensätze für die UITableView gespeichert werden. Neben der Definition dieser Eigenschaften werden wir auch die Event.h-Datei importieren, damit wir die Klasse verwenden können.
TimeTableController.h
#einführen#import "Event.h" @interface TimeTableController: UITableViewController NSManagedObjectContext * managedObjectContext; NSMutableArray * eventArray; @ property (nicht atomar, beibehalten) NSManagedObjectContext * managedObjectContext; @ property (nonatomic, keep) NSMutableArray * eventArray; - (void) fetchRecords; - (void) addTime: (id) Absender; @Ende
Was ist ein NSManagedObjectContext? Es wird als "Notizblock" für Core Data in der Anwendung zum Verwalten von Abrufen, Aktualisieren und Erstellen von Datensätzen im Geschäft bezeichnet. Es verwaltet auch einige grundlegende Funktionen in Core Data, einschließlich Validierungen und Undo / Redo-Management für die Datensätze.
Der verwaltete Objektkontext ist die Verbindung zwischen Ihrem Code und dem Datenspeicher. Alle Operationen, die Sie für Core Data ausführen, werden für den Kontext des verwalteten Objekts ausgeführt. Wenn eine Anforderung ausgeführt wird, spricht der verwaltete Objektkontext dann mit dem Koordinator für beständigen Speicher, der für die Zuordnung der Objekte zu Daten für den Datenspeicher verantwortlich ist. Dadurch können die Kerndaten zwischen verschiedenen Datenspeicherformaten flexibel sein. Hier ist ein Diagramm, wie das aussieht.
Wenn die Headerdatei definiert ist, müssen wir die zugewiesenen Eigenschaften und Methoden in der Implementierungsdatei weitergeben.
TimeTableController.m
#import "TimeTableController.h" @implementation TimeTableController @synthesize managedObjectContext, eventArray; //… //… standardmäßig kommentierter Code aus der Dateivorlage //… - (void) viewDidLoad [super viewDidLoad]; self.title = @ "Rundenzeiten"; UIBarButtonItem * addButton = [[UIBarButtonItem-Zuordnung] initWithBarButtonSystemItem: UIBarButtonSystemItemAdd Ziel: Eigenaktion: @selector (addTime :)]; self.navigationItem.rightBarButtonItem = addButton; [addButton release]; [Self FetchRecords]; - (void) addTime: (id) sender Ereignis * Ereignis = (Ereignis *) [NSEntityDescription insertNewObjectForEntityForName: @ "Ereignis" inManagedObjectContext: managedObjectContext]; [event setTimeStamp: [NSDate-Datum]]; NSError * Fehler; if (! [managedObjectContext save: & error]) // Dies ist ein schwerwiegender Fehler, der besagt, dass der Datensatz nicht gespeichert werden konnte. Weisen Sie den Benutzer an, // erneut zu versuchen oder die Anwendung neu zu starten. [eventArray insertObject: event atIndex: 0]; [self.tableView reloadData]; - (void) fetchRecords // Definiere unsere Tabelle / Entität zur Verwendung von NSEntityDescription * entity = [NSEntityDescription entityForName: @ "Event" inManagedObjectContext: managedObjectContext]; // Die Abrufanforderung einrichten NSFetchRequest * request = [[NSFetchRequest Allocation] init]; [request setEntity: entity]; // Definiere, wie wir die Datensätze sortieren NSSortDescriptor * sortDescriptor = [[NSSortDescriptor Allocation] initWithKey: @ "timeStamp" aufsteigend: NO]; NSArray * sortDescriptors = [NSArray arrayWithObject: sortDescriptor]; [request setSortDescriptors: sortDescriptors]; [sortDescriptor release]; // Holen Sie die Datensätze ab und behandeln Sie einen Fehler. NSError * error; NSMutableArray * mutableFetchResults = [[managedObjectContext executeFetchRequest: Anforderungsfehler: & Fehler] MutableCopy]; if (! mutableFetchResults) // Behandelt den Fehler. // Dies ist ein schwerwiegender Fehler und sollte dem Benutzer empfehlen, die Anwendung neu zu starten. // Speichern Sie unsere abgerufenen Daten in einem Array [self setEventArray: mutableFetchResults]; [mutableFetchResults release]; [Freigabe beantragen]; //… //… weitere Vorlagenkommentare und Standardmethodendefinitionen //… - (void) dealloc [managedObjectContext release]; [eventArray release]; [Super Dealloc]; @Ende
Das ist ziemlich viel Code, also lassen wir uns von jeder Methode einzeln durchgehen. Es gibt Code, wenn Sie die Datei aus der Vorlage erstellen, auskommentierte Methoden wie viewDidUnload, die ich gerade oben weggelassen habe.
Wir beginnen mit dem üblichen Ruf in die Superklasse. Dann definieren wir den Titel der UINavigationBar. Danach müssen wir die Schaltfläche definieren, mit der wir einen Datensatz zum Core Data Store hinzufügen. Wenn die Taste gedrückt wird, wird der Selektor addTime aufgerufen, der mit Core Data interagiert. Nach den erforderlichen Releases rufen wir die Funktion fetchRecords auf, die im Folgenden erläutert wird.
Dies wird ausgelöst, wenn UIBarButtonItem oben rechts in der UINavigationBar gedrückt wird. Wir müssen einen neuen Ereignisdatensatz mit dem aktuellen NSDate erstellen und in der Datenbank speichern.
Wir erstellen einen neuen Ereignisdatensatz, der als NSEntityDescription bezeichnet wird. Dies ist Ihre Zeile in der Datenbank für den neuen Datensatz. Dazu definieren wir den Entitätsnamen, zu dem der Datensatz gehört, und geben den NSManagedObjectContext an. Das aktuelle Datum wird dann mit dem timeStamp-Attribut abgeglichen.
Die Sicherungsoperation wird dann ausgeführt, aber es ist eine Möglichkeit vorhanden, einen Fehler zu behandeln, falls das Einfügen fehlschlägt. Normalerweise werfen Sie eine UIAlertView, die besagt, dass der Datensatz nicht erstellt wurde, und weist den Benutzer möglicherweise an, es erneut zu versuchen oder die Anwendung zu schließen und wieder zu öffnen.
Der Datensatz muss zu dem Array hinzugefügt werden, aus dem UITableView gespeist wird. Dann muss die UITableView angewiesen werden, die Daten neu zu laden. Sie können dies grafischer mit einer Animation machen, aber für das Tutorial lassen Sie uns einfach bleiben.
Diese Methode holt die Daten aus dem Speicher und fügt sie dem Array hinzu, das sich im Controller befindet. Um weitere Details zum Abrufen von Datensätzen zu erhalten, werfen wir einen Blick auf NSFetchRequest.
Core Data verfolgt einen anderen Ansatz, um Daten aus seiner Datenbank abzurufen. Es ist ein NoSQL-Datenspeicher. Das bedeutet, dass alle Bedingungen einer Abfrage auf Methoden basieren. Dies ist großartig, da der Basisspeicher, also SQLite, auf jede andere Datenbanktechnologie geändert werden kann und die einzige Änderung die Verbindung und die Treiber für die Datenbank sind.
Um eine Anfrage zu erstellen, erstellen wir ein NSFetchRequest-Objekt. Dies ist das Basisobjekt, für das die Abfragebedingungen festgelegt werden. Wir können Bedingungen für den Abgleich einer bestimmten Eigenschaft basierend auf der Reihenfolge der Datensätze definieren. Weitere Informationen zu Core Data und den Bedingungen für NSFetchRequests finden Sie in der Dokumentation.
Das Erstellen einer neuen NSFetch-Anforderung ist einfach. Sie müssen lediglich die Entität definieren, von der Datensätze abgerufen werden sollen, sowie den NSManagedObjectContext.
NSEntityDescription * entity = [NSEntityDescription entityForName: @ "Event" inManagedObjectContext: managedObjectContext]; NSFetchRequest * request = [[NSFetchRequest-Zuordnung] init]; [request setEntity: entity];
Die Entität wird mithilfe eines NSEntityDescription-Objekts definiert, das den Entitätsnamen und den NSManagedObjectContext erfordert. Die Abrufanforderung wird dann erstellt, wobei die Entitätsbeschreibung übergeben wird. Dies würde dem ersten Teil einer SQL-Anweisung entsprechen:
SELECT * FROM 'Ereignisse'
In unserer Beispielanwendung sortieren wir die Daten absteigend nach timeStamp. Dazu verwenden wir einen NSSortDescriptor.
NSSortDescriptor * sortDescriptor = [[NSSortDescriptor-Zuordnung] initWithKey: @ "timeStamp" aufsteigend: NEIN]; NSArray * sortDescriptors = [NSArray arrayWithObject: sortDescriptor]; [request setSortDescriptors: sortDescriptors]; [sortDescriptor release];
Der NSSortDescriptor wird erstellt und wir definieren das Attribut, das wir sortieren möchten, und ob es aufsteigend ist. In diesem Fall möchten wir, dass es absteigend wird, sodass es auf NO gesetzt wird. Die Abrufanforderung kann viele Sortierdeskriptoren annehmen, so dass sie beim Festlegen der Sortierdeskriptoren ein Array akzeptiert. Da wir nur ein Objekt benötigen, müssen wir nur ein Array mit einem Objekt erstellen. Wir setzen das Deskriptor-Array gegen die Abrufanforderung und das ist es.
Um eine Bedingung zu definieren, die einem Datensatzinhalt entspricht, kommt die Klasse NSPredicate zum Einsatz. Es ermöglicht, dass die Abrufanforderung übereinstimmt oder einen Bereich definiert, den der Inhalt eines Datensatzes erfüllen muss. Dies ist das Äquivalent zu Ihren Gleichen, mehr und weniger als Übereinstimmungen in SQL. Es hat mehr als Ihre grundlegenden SQL-Funktionen, die Sie hier sehen können.
Das Setzen eines Prädikats kann sehr einfach sein.
NSPredicate * predicate = [NSPredicate predicateWithFormat: @ "(Nachname wie% @) AND (Geburtstag>% @)", lastNameSearchString, birthdaySearchDate];
Verwenden von NSPredicate predicateWithFormat: ist eine einfache und vertraute Methode, mit der Sie die Bedingungen der Abfrage definieren können. Für eine ausführliche Erklärung zu NSPredicates enthält die Apple-Dokumentation einige nützliche Anleitungen.
Wenn Sie die Bedingungen in Ihrer Abrufanforderung definiert haben, können Sie sie ausführen.
NSMutableArray * mutableFetchResults = [[managedObjectContext executeFetchRequest: Anforderungsfehler: & Fehler] MutableCopy];
Dadurch wird ein Array von Entitätsobjekten (NSManagedObjects) zur Verwendung in Ihrer Datenausgabe zurückgegeben.
Nachdem die Daten aus Core Data abgerufen und im eventArray gespeichert wurden, können wir diese Datensätze nun in UITableView ausgeben.
Als Erstes sagen Sie der Tabelle, dass wir nur einen Abschnitt benötigen und wie viele Zeilen wir verwenden müssen.
Auszug aus TimeTableController.m
-(NSInteger) numberOfSectionsInTableView: (UITableView *) tableView return 1; - (NSInteger) tableView: (UITableView *) tableView numberOfRowsInSection: (NSInteger) Abschnitt return [eventArray count];
Wenn Sie zuvor einen UITableViewController verwendet haben, sollte die nächste Funktion unkompliziert sein.
-(UITableViewCell *) tableView: (UITableView *) tableView cellForRowAtIndexPath: (NSIndexPath *) indexPath statischer NSString * CellIdentifier = @ "Cell"; statisch NSDateFormatter * dateFormatter = nil; if (dateFormatter == nil) dateFormatter = [[NSDateFormatter-Zuordnung] init]; [dateFormatter setDateFormat: @ "h: mm.ss a"]; UITableViewCell * cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier]; if (cell == nil) cell = [[[UITableViewCell Allocation] initWithStyle: UITableViewCellStyleValue1 reuseIdentifier: CellIdentifier] Autorelease]; Event * event = [eventArray objectAtIndex: [indexPath-Zeile]]; Event * previousEvent = null; if ([eventArray count]> ([indexPath-Zeile] + 1)) previousEvent = [eventArray objectAtIndex: ([indexPath-Zeile] + 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: @ "---"]; Zelle zurückgeben;
In der Zelle werden 2 Werte angezeigt, und zwar im UITableViewCellStyleValue1-Stil. Links ist die Zeit der Runde und rechts die Differenz in Sekunden vom vorherigen Datensatz.
Da diese Methode wiederholt wird, müssen wir besonders auf die Last achten, die das Gerät unterbinden kann, wenn es nicht ordnungsgemäß verwaltet wird. Aus diesem Grund wird der NSDatFormatter als statische Variable gespeichert, sodass er in jeder Iteration wiederverwendet werden kann, ohne dass er jedes Mal zugewiesen und freigegeben wird.
Lazy Loading ist eine Technik, bei der Sie die Anforderung oder Zuweisung einer Eigenschaft so weit wie möglich verzögern. Dies hilft, den Speicher niedrig zu halten, und bei iterativen Funktionen ist dies von größter Bedeutung. Um zu wissen, wann und wie Daten zugewiesen werden, ist es entscheidend, um eine mobile App schnell zu halten. Die Zuordnung des Objekts ist ebenso wichtig, je früher, desto besser.
cellForRowAtIndexPath: ist eine iterative Methode, und alle in dieser Methode verarbeiteten oder zugewiesenen Daten müssen auf einem Minimum gehalten werden. Diese Methode wird immer dann ausgeführt, wenn eine Zelle angezeigt wird. Wenn ein Benutzer schnell scrollt, kann diese bestimmte Methode, abhängig von der Datensatzmenge, sehr häufig nacheinander aufgerufen werden.
Die nächste Aufgabe besteht darin, das Ereignisobjekt mit der Tabellenzeile zu verknüpfen, die gerendert werden muss. Da wir den vorherigen Datensatz für den Zeitvergleich abrufen müssen, wird einfach überprüft, ob ein früherer Datensatz vorhanden ist, und um ihn in previousEvent zu speichern. Wenn das vorherige Ereignis vorhanden ist, berechnen wir die Aufteilung mit [NSDate timeIntervalSinceDate: (NSDate)]. Das textLabel und das detailTextLabel werden dann mit den berechneten Werten festgelegt.
Mit dem UITableViewController-Setup und der Tabellendatenquelle, die mit dem Core Data-Speicher zusammenarbeitet, müssen Sie nur den Controller laden, wenn die Anwendung gestartet wird.
Im Application Controller muss eine UINavigationController-Eigenschaft definiert werden. Dann muss die applicationDidFinishLaunching-Methode nur den Controller zuweisen, und wir sind fertig.
LapTimerAppDelegate.h
@Interface LapTimerAppDelegate: NSObjectNSManagedObjectModel * managedObjectModel; NSManagedObjectContext * managedObjectContext; NSPersistentStoreCoordinator * persistentStoreCoordinator; UIWindow * -Fenster; UINavigationController * navigationController; @ property (nonatomic, keep, readonly) NSManagedObjectModel * managedObjectModel; @ property (nonatomic, keep, readonly) NSManagedObjectContext * managedObjectContext; @ property (nonatomic, keep, readonly) NSPersistentStoreCoordinator * persistentStoreCoordinator; @ property (nichtatomisch, beibehalten) IBOutlet UIWindow * -Fenster; @ property (nonatomic, keep) UINavigationController * navigationController; - (NSString *) applicationDocumentsDirectory; @Ende
Auszug aus LapTimerAppDelegate.m
#import "LapTimerAppDelegate.h" #import "TimeTableController.h" @implementation LapTimerAppDelegate @synthesize-Fenster, navigationController; - (void) applicationDidFinishLaunching: (UIApplication *) -Anwendung TimeTableController * tableController = [[TimeTableController-Zuweisung] tableController.managedObjectContext = [self managedObjectContext]; self.navigationController = [[Zuordnung UINavigationController] initWithRootViewController: tableController]; [TableController Release]; [Fenster addSubview: [self.navigationController-Ansicht]]; [Fenster makeKeyAndVisible]; //… //… andere Vorlagenmethoden //… - (void) dealloc [managedObjectContext release]; [managedObjectModel-Version]; [persistentStoreCoordinator-Version]; [Fensterfreigabe]; [navigationController release]; [Super Dealloc];
Die Datei TimeTableController.h ist im Anwendungsdelegierten enthalten und wird dann mit einem UINavigationController zugewiesen.
Das sollte es sein. Erstellen Sie die Anwendung, um nach Fehlern zu suchen. Einige der Codebeispiele waren nur Auszüge. Kein Code, der beim Erstellen einer Datei generiert wurde, wurde entfernt und nur ausgefüllt. Wenn Fehler auftreten, die nicht geknackt werden können, können Sie die an dieses Tutorial angehängte Projektdatei herunterladen die Sie dann kompilieren und vergleichen können.
Führen Sie die Anwendung aus. Sie sehen den Navigationscontroller und die Schaltfläche "Hinzufügen". Klicken Sie auf die Schaltfläche Hinzufügen, um eine neue Zeit in der Tabelle anzuzeigen.
In diesem Lernprogramm haben wir eine Beispielanwendung erstellt, um einfache Daten in einem Core Data Store zu speichern. Die Anwendung hat die Ersteinrichtung beim Erstellen einer Anwendung mit Core Data durchlaufen, die Datenstruktur definiert und Datensätze aus dem Datenspeicher abgerufen.
Hoffentlich haben Sie eine Einführung in Core Data erhalten und können sehen, wie einfach es zu verwenden ist und wie es die Leistung und Funktionalität Ihrer Anwendungen verbessern kann.
Wenn Sie mehr über Core Data erfahren möchten oder einen detaillierten Einblick in die Struktur des Frameworks erhalten möchten, ist die Apple Developer Documentation der ideale Ort.
Apple-Entwicklerdokumentation:
Einführung in die Kerndatenprogrammierung
Kerndatenmigration und Versionierung
NSPredicate-Programmierhandbuch:
Accentsconagua