Nur um alle Schritte zu erläutern, die Sie tatsächlich ausführen müssen, um einem Projekt, das es zuvor nicht hatte, Kerndaten hinzuzufügen:
Schritt 1: Fügen Sie das Framework hinzu
Klicken Sie auf Ihr App-Ziel (im linken Bereich befindet sich das obere Symbol mit dem Namen Ihrer App), gehen Sie zur Registerkarte "Phasen erstellen" und dann auf "Binär mit Bibliotheken verknüpfen". Klicken Sie auf das kleine "+" unten und suchen Sie 'CoreData.framework' und fügen Sie es Ihrem Projekt hinzu
Importieren Sie dann entweder Coredaten für alle Objekte, die Sie benötigen (auf nicht sexy Weise), indem Sie:
Schnell
import CoreData
Ziel c
#import <CoreData/CoreData.h>
oder fügen Sie den Import unter den üblichen Importen in Ihre .pch-Datei (viel sexy) wie folgt hinzu:
#ifdef __OBJC__
#import <UIKit/UIKit.h>
#import <Foundation/Foundation.h>
#import <CoreData/CoreData.h>
#endif
Schritt 2: Fügen Sie das Datenmodell hinzu
Um die .xcdatamodel-Datei hinzuzufügen, klicken Sie mit der rechten Maustaste auf Ihre Dateien im rechten Bereich (wie in einem Ressourcenordner zur sicheren Aufbewahrung) und wählen Sie "Neue Datei hinzufügen". Klicken Sie bei Auswahl Ihres Dateityps auf die Registerkarte "Kerndaten" und dann auf "Klicken Sie auf". Datenmodell ', geben Sie ihm einen Namen und klicken Sie auf Weiter und Fertig stellen. Es wird dann Ihrem Projekt hinzugefügt. Wenn Sie auf dieses Modellobjekt klicken, wird die Oberfläche angezeigt, über die Sie die Entitäten mit den gewünschten Beziehungen zu Ihrem Projekt hinzufügen können.
Schritt 3: App Delegate aktualisieren
In Swift auf AppDelegate.swift
//replace the previous version of applicationWillTerminate with this
func applicationWillTerminate(application: UIApplication) {
// Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
// Saves changes in the application's managed object context before the application terminates.
self.saveContext()
}
func saveContext () {
var error: NSError? = nil
let managedObjectContext = self.managedObjectContext
if managedObjectContext != nil {
if managedObjectContext.hasChanges && !managedObjectContext.save(&error) {
// Replace this implementation with code to handle the error appropriately.
// abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
//println("Unresolved error \(error), \(error.userInfo)")
abort()
}
}
}
// #pragma mark - Core Data stack
// Returns the managed object context for the application.
// If the context doesn't already exist, it is created and bound to the persistent store coordinator for the application.
var managedObjectContext: NSManagedObjectContext {
if !_managedObjectContext {
let coordinator = self.persistentStoreCoordinator
if coordinator != nil {
_managedObjectContext = NSManagedObjectContext()
_managedObjectContext!.persistentStoreCoordinator = coordinator
}
}
return _managedObjectContext!
}
var _managedObjectContext: NSManagedObjectContext? = nil
// Returns the managed object model for the application.
// If the model doesn't already exist, it is created from the application's model.
var managedObjectModel: NSManagedObjectModel {
if !_managedObjectModel {
let modelURL = NSBundle.mainBundle().URLForResource("iOSSwiftOpenGLCamera", withExtension: "momd")
_managedObjectModel = NSManagedObjectModel(contentsOfURL: modelURL)
}
return _managedObjectModel!
}
var _managedObjectModel: NSManagedObjectModel? = nil
// Returns the persistent store coordinator for the application.
// If the coordinator doesn't already exist, it is created and the application's store added to it.
var persistentStoreCoordinator: NSPersistentStoreCoordinator {
if !_persistentStoreCoordinator {
let storeURL = self.applicationDocumentsDirectory.URLByAppendingPathComponent("iOSSwiftOpenGLCamera.sqlite")
var error: NSError? = nil
_persistentStoreCoordinator = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
if _persistentStoreCoordinator!.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: storeURL, options: nil, error: &error) == nil {
/*
Replace this implementation with code to handle the error appropriately.
abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
Typical reasons for an error here include:
* The persistent store is not accessible;
* The schema for the persistent store is incompatible with current managed object model.
Check the error message to determine what the actual problem was.
If the persistent store is not accessible, there is typically something wrong with the file path. Often, a file URL is pointing into the application's resources directory instead of a writeable directory.
If you encounter schema incompatibility errors during development, you can reduce their frequency by:
* Simply deleting the existing store:
NSFileManager.defaultManager().removeItemAtURL(storeURL, error: nil)
* Performing automatic lightweight migration by passing the following dictionary as the options parameter:
[NSMigratePersistentStoresAutomaticallyOption: true, NSInferMappingModelAutomaticallyOption: true}
Lightweight migration will only work for a limited set of schema changes; consult "Core Data Model Versioning and Data Migration Programming Guide" for details.
*/
//println("Unresolved error \(error), \(error.userInfo)")
abort()
}
}
return _persistentStoreCoordinator!
}
var _persistentStoreCoordinator: NSPersistentStoreCoordinator? = nil
// #pragma mark - Application's Documents directory
// Returns the URL to the application's Documents directory.
var applicationDocumentsDirectory: NSURL {
let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
return urls[urls.endIndex-1] as NSURL
}
Stellen Sie in Ziel C sicher, dass Sie diese Objekte zu AppDelegate.h hinzufügen
@property (nonatomic, retain, readonly) NSManagedObjectModel *managedObjectModel;
@property (nonatomic, retain, readonly) NSManagedObjectContext *managedObjectContext;
@property (nonatomic, retain, readonly) NSPersistentStoreCoordinator *persistentStoreCoordinator;
- (NSURL *)applicationDocumentsDirectory; // nice to have to reference files for core data
Synthetisieren Sie die vorherigen Objekte in AppDelegate.m folgendermaßen:
@synthesize managedObjectContext = _managedObjectContext;
@synthesize managedObjectModel = _managedObjectModel;
@synthesize persistentStoreCoordinator = _persistentStoreCoordinator;
Fügen Sie dann diese Methoden zu AppDelegate.m hinzu (stellen Sie sicher, dass Sie den Namen des Modells, das Sie hinzugefügt haben, an den angezeigten Stellen einfügen):
- (void)saveContext{
NSError *error = nil;
NSManagedObjectContext *managedObjectContext = self.managedObjectContext;
if (managedObjectContext != nil) {
if ([managedObjectContext hasChanges] && ![managedObjectContext save:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
}
}
- (NSManagedObjectContext *)managedObjectContext{
if (_managedObjectContext != nil) {
return _managedObjectContext;
}
NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
if (coordinator != nil) {
_managedObjectContext = [[NSManagedObjectContext alloc] init];
[_managedObjectContext setPersistentStoreCoordinator:coordinator];
}
return _managedObjectContext;
}
- (NSManagedObjectModel *)managedObjectModel{
if (_managedObjectModel != nil) {
return _managedObjectModel;
}
NSURL *modelURL = [[NSBundle mainBundle] URLForResource:@"NAMEOFYOURMODELHERE" withExtension:@"momd"];
_managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
return _managedObjectModel;
}
- (NSPersistentStoreCoordinator *)persistentStoreCoordinator
{
if (_persistentStoreCoordinator != nil) {
return _persistentStoreCoordinator;
}
NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"NAMEOFYOURMODELHERE.sqlite"];
NSError *error = nil;
_persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
if (![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
return _persistentStoreCoordinator;
}
#pragma mark - Application's Documents directory
// Returns the URL to the application's Documents directory.
- (NSURL *)applicationDocumentsDirectory{
return [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
}
Schritt 4: Bringen Sie die Datenobjekte zu den ViewControllern, auf denen Sie die Daten benötigen
Option 1. Verwenden Sie den ManagedObjectContext des App-Delegaten von VC (bevorzugt und einfacher).
Wie von @ brass-kazoo vorgeschlagen - Rufen Sie einen Verweis auf AppDelegate und seinen verwalteten Objektkontext über Folgendes ab:
Schnell
let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
appDelegate.managedObjectContext
Ziel c
[[[UIApplication sharedApplication] delegate] managedObjectContext];
in Ihrem ViewController
Option 2. Erstellen Sie ManagedObjectContext in Ihrer VC und lassen Sie es mit AppDelegates aus dem AppDelegate (Original) übereinstimmen.
Zeigt nur die alte Version für Ziel C an, da die bevorzugte Methode viel einfacher zu verwenden ist
im ViewController.h
@property (nonatomic, retain) NSManagedObjectContext *managedObjectContext;
Im ViewController.m
@synthesize managedObjectContext = _managedObjectContext;
Stellen Sie in AppDelegate oder der Klasse, in der der ViewController erstellt wird, fest, dass der verwaltete Objekttext mit dem AppDelegate identisch ist
ViewController.managedObjectContext = self.managedObjectContext;
Wenn Sie möchten, dass der Viewcontroller, der Core Data verwendet, ein FetchedResultsController ist, müssen Sie sicherstellen, dass sich dieses Material in Ihrem ViewController.h befindet
@interface ViewController : UIViewController <NSFetchedResultsControllerDelegate> {
NSFetchedResultsController *fetchedResultsController;
NSManagedObjectContext *managedObjectContext;
}
@property (nonatomic, retain) NSFetchedResultsController *fetchedResultsController;
Und das ist in ViewController.m
@synthesize fetchedResultsController, managedObjectContext;
Nach all dem können Sie jetzt diesen manageObjectContext verwenden, um alle üblichen fetchRequests auszuführen, die für die CoreData-Güte erforderlich sind! Genießen
