Core Data（Initializing the Core Data Stack）

Core Data 的堆栈（stack）是一个框架对象的集合，作为Core Data 的初始化部分进行访问，并在应用程序和外部数据存储之间进行调解。Core Data处理所有与外部数据存储的交互，以便你的应用可以更专注与逻辑处理。Core Data的堆栈（stack）包主要包含四个对象：管理对象上下文（NSManagedOberjctContext），持久性储存协调器（NSPersistentStoreCoordinator），托管对象的模型（NSManagedObjectModel），持久化容器（NSPerSistentContainer）。

在访问应用程序的数据之前初始化Core Data的堆栈（stack）。堆栈（stack）的初始化为Core Data对数据的请求和创建做了准备。下面是如何创建Core Data的堆栈（stack）的示例。

Objective-C

@interface MyDataController : NSObject 

@property (strong, nonatomic, readonly) NSPersistentContainer *persistentContainer;

 - (id)initWithCompletionBlock:(CallbackBlock)callback;

@end
 
@implementation MyDataController

 - (id)init {
    self = [super init];
    if (!self) return nil;
    self.persistentContainer = [[NSPersistentContainer alloc] initWithName:@"DataModel"];
    [self.persistentContainer loadPersistentStoresWithCompletionHandler:^(NSPersistentStoreDescription *description, NSError *error) {
        if (error != nil) {
            NSLog(@"Failed to load Core Data stack: %@", error);
            abort();
        }
        callback();
    }];
    return self;
}

SWIFT

import UIKit
import CoreData
class DataController: NSObject {
    var managedObjectContext: NSManagedObjectContext
    init(completionClosure: @escaping () -> ()) {
        persistentContainer = NSPersistentContainer(name: "DataModel")
        persistentContainer.loadPersistentStores() { (description, error) in
            if let error = error {
                fatalError("Failed to load Core Data stack: \(error)")
            }
            completionClosure()
        }
    }
}

这个示例创建了一个应用程序持久层的控制器对象（controller object）。这个控制器（controller）默认为init初始化方法，作为这个init方法的一部分，初始化Core Data的方法被调用，并进而创建了Core Data的堆栈（stack）。

持久化容器（NSPersistentContainer）

从IOS10和MacOS10.12开始，NSpersistentContainer处理Core Data的堆栈（stack）的创建，并且提供NSManagedObejctContext的一些便利方法。在IOS10和MacOS10.12之前，创建Core Data的堆栈（stack）要更加的复杂。

Objective-C

- (id)initWithCompletionBlock:(CallbackBlock)callback；
{
    self = [super init];
    if (!self) return nil;
    //This resource is the same name as your xcdatamodeld contained in your project
    NSURL *modelURL = [[NSBundle mainBundle] URLForResource:@"Workspace" withExtension:@"momd"];
    NSAssert(modelURL, @"Failed to locate momd bundle in application");
    // The managed object model for the application. It is a fatal error for the application not to be able to find and load its model.
    NSManagedObjectModel *mom = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
    NSAssert(mom, @"Failed to initialize mom from URL: %@", modelURL);
 
    NSPersistentStoreCoordinator *coordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:mom];
 
    NSManagedObjectContext *moc = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
    [moc setPersistentStoreCoordinator:coordinator];
    [self setManagedObjectContext:moc];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
        NSPersistentStoreCoordinator *psc = [[self managedObjectContext] persistentStoreCoordinator];
        NSFileManager *fileManager = [NSFileManager defaultManager];
        NSURL *documentsURL = [[fileManager URLsForDirectory:NSDocumentationDirectory inDomains:NSUserDomainMask] lastObject];
        // The directory the application uses to store the Core Data store file. This code uses a file named "DataModel.sqlite" in the application's documents directory.
        NSURL *storeURL = [documentsURL URLByAppendingPathComponent:@"DataModel.sqlite"];
 
        NSError *error = nil;
        NSPersistentStore *store = [psc addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error];
        if (!store) {
            NSLog(@"Failed to initalize persistent store: %@\n%@", [error localizedDescription], [error userInfo]);
            abort();
            //A more user facing error message may be appropriate here rather than just a console log and an abort
        }
        if (!callback) {
            //If there is no callback block we can safely return
            return;
        }
        //The callback block is expected to complete the User Interface and therefore should be presented back on the main queue so that the user interface does not need to be concerned with which queue this call is coming from.
        dispatch_sync(dispatch_get_main_queue(), ^{
            callback();
        });
    });
    return self;
}

Swift

init(completionClosure: @escaping () -> ()) {
    //This resource is the same name as your xcdatamodeld contained in your project
    guard let modelURL = Bundle.main.url(forResource: "DataModel", withExtension:"momd") else {
        fatalError("Error loading model from bundle")
    }
    // The managed object model for the application. It is a fatal error for the application not to be able to find and load its model.
    guard let mom = NSManagedObjectModel(contentsOf: modelURL) else {
        fatalError("Error initializing mom from: \(modelURL)")
    }
    
    let psc = NSPersistentStoreCoordinator(managedObjectModel: mom)
    
    managedObjectContext = NSManagedObjectContext(concurrencyType: NSManagedObjectContextConcurrencyType.mainQueueConcurrencyType)
    managedObjectContext.persistentStoreCoordinator = psc

    let queue = DispatchQueue.global(qos: DispatchQoS.QoSClass.background)

    queue.async {
        guard let docURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).last else {
            fatalError("Unable to resolve document directory")
        }
        let storeURL = docURL.appendingPathComponent("DataModel.sqlite")
        do {
            try psc.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: storeURL, options: nil)
            //The callback block is expected to complete the User Interface and therefore should be presented back on the main queue so that the user interface does not need to be concerned with which queue this call is coming from.
            DispatchQueue.main.sync(execute: completionClosure)
        } catch {
            fatalError("Error migrating store: \(error)")
        }
    }
}

除了在Core Data的堆栈（stack）建设之外，NSPersistentContainer同样为开发人员使用应用的多线程时提供了一些便利方法。

托管对象模型（NSManagedObjectModel）

NSManagedObjectModel的实例（实例化）描述了Core Data的堆栈（stack）将要访问的数据。在Core Data的堆栈（stack）创建的期间，NSManagedObjectModel在堆栈（stack）创建时第一个被创建并且加载到内存中。上面的代码使用了一个已知程序主bundle的文件名的NSURL。在NSManagedObjectModel初始化之后，NSPersistertStroreCoordinator被创建了。

持久性储存协调器（NSPersistentStoreCoordinator）

NSPersistentStoreCoordinator是在Core Data的堆栈（stack）的中间位置。协调器是负责把定义在模型里entities实现成实例。协调器把模型里的entities创建成一个新的实例，并且从数据持久储存（NSPersistentStore）中检索现有的实例。数据持久化可以持久储存在磁盘（disk）或者内存总线（memory）。取决于应用程序的结构，有可能有超过一个的持久化储存通过NSPersistentStoreCoordinator来协调，虽然很罕见。

鉴于NSManagedObjectModel定义了数据的结构，NSPersistentStoreCoordinator从持久化储存的数据中实现对象，并且通过这些对象去请求NSManagedObjectContext。这也表明NSPersistentStoreCoordinator的数据在一个匹配定义一致的NSManagedObjectContext。

调用添加NSPersistentStoreCoordinator的NSPersistentStore时异步进行。少数情况下会引起调用线程的阻塞（例如，继承iCloud和迁移）。因此，最好使用异步执行请求调用，以避免用户界面队列的阻塞。

管理对象上下文（NSManagedObjectContext）

管理对象上下文（NSManagedObjectContext）是应用程序经常联系（使用）的对象，因此，在你的应用程序中只有一个并且暴露在应用程序中（类似单例模式）。NSManagedObjectContext类似与智能便签。当你从持久化数据中获取对象时，会在这个智能便签上创建一个临时的对象副本，从而形成一个对象图（object graphs）（或者是对象图（object graphs）的集合）。你可以随意修改这些对象，在你真的保存这些修改之前，持久保存的数据是保持不变的。

所有的管理对象必须在管理对象的上下文中注册。使用上下文（context）讲对象添加到对象图中或者从对象图中一处对象。上下文（context）跟踪你所做的更改，无论是对单个对象的属性更改，还是对象之间的关系更改。通过追踪更改，上下文（context）可以为你提供撤销和重做的支持。它还可以在改变了对象之间的关系时，确保对象图的完整性。

如果你要保存所做的更改，上下文（context）会确保这些对象处于有效状态。对象处于有效状态，这些更改才会被写入持久化储存中，为你创建的对象添加新的记录，并且移除那些你删除的记录。

如果没有Core Data，你必须写支持归档和数据持久化的方法，跟踪对象的模型，并且还要有撤销管理和撤销方法。在Core Data的框架中，大多数的功能都是紫铜提供的，主要通过管理对象上下文（managed object context）。