我们为什么可以使用的NSManagedObjectContext没有CoreData设置其persistentStoreCoordinator

Question

上下文的正常初始化是这样的：

lazy var context : NSManagedObjectContext = { 
let context = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType) 
context.persistentStoreCoordinator = self.coordinator 
return context 
}() 

但为什么我可以初始化在这样的背景下：

var managedObjectContext : NSManagedObjectContext? 
lazy var note: Note? = { 
if let context = self.managedObjectContext { 
    return NSEntityDescription.insertNewObjectForEntityForName("Note", inManagedObjectContext: context) as? Note 
} 
return .None 
}() 

如果我没有设置persistentStoreCoordinator，则上下文将以哪种方式存储实体。顺便说一句，这不是在演示中创建的第一个上下文，它只是一个名为Node的manageredobject的上下文，其节点号为

在线等待..........

整个代码为：

import UIKit 

import CoreData 

class CreateNoteViewController : UIViewController, UITextFieldDelegate, UITextViewDelegate { 
var managedObjectContext : NSManagedObjectContext? 
    lazy var note: Note? = { 
    if let context = self.managedObjectContext { 
     return NSEntityDescription.insertNewObjectForEntityForName("Note", inManagedObjectContext: context) as? Note 
} 
return .None 
}() 

    @IBOutlet var titleField : UITextField! 
    @IBOutlet var bodyField : UITextView! 
    @IBOutlet var attachPhotoButton : UIButton! 
    @IBOutlet var attachedPhoto : UIImageView! 

    override func viewDidAppear(animated: Bool) { 
super.viewDidAppear(animated) 
if let image = note?.image { 
    attachedPhoto.image = image 
    view.endEditing(true) 
} else { 
    titleField.becomeFirstResponder() 
} 
} 


    @IBAction func saveNote() { 
    note?.title = titleField.text 
    note?.body = bodyField.text 

    if let managedObjectContext = managedObjectContext { 
    do { 
    try managedObjectContext.save() 
} 
    catch let error as NSError { 
print("Error saving \(error)", terminator: "") 
    } 
    } 
    performSegueWithIdentifier("unwindToNotesList", sender: self) 
} 

    func textFieldShouldReturn(textField: UITextField) -> Bool { 
    saveNote() 
    textField.resignFirstResponder() 
    return false 
    } 

    override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject!) { 
    if segue.identifier == "AttachPhoto" { 
if let nextViewController = segue.destinationViewController as? AttachPhotoViewController { 
nextViewController.note = note 
} 
    } 
    } 
    } 

的视图控制器的功能是从本地报警挑选一张照片，并保存标题，节点用来保存所有的信息，所以作者确实使用了默认的上下文（即使我不知道为什么他不使用默认上下文），他初始化一个新的上下文来保存节点，即使没有设置任何东西，其惊人的，即使他没有设置的文件路径的路径， 我会告诉你默认的堆栈：

 import Foundation 
     import CoreData 

    class CoreDataStack: CustomStringConvertible { 
     var modelName : String 
     var storeName : String 
     var options : [String : AnyObject]? 

     init(modelName:String, storeName:String, options: [String : AnyObject]? = nil) { 
self.modelName = modelName 
self.storeName = storeName 
self.options = options 
     } 

     var description : String { 
return "context: \(context)\n" + 
    "modelName: \(modelName)" + 
    "storeURL: \(storeURL)\n" 
     } 

    var modelURL : NSURL { 
return NSBundle.mainBundle().URLForResource(self.modelName, withExtension: "momd")! 
    } 

    var storeURL : NSURL { 
var storePaths = NSSearchPathForDirectoriesInDomains(.ApplicationSupportDirectory, .UserDomainMask, true) as [String] 
let storePath = String(storePaths[0]) as NSString 
let fileManager = NSFileManager.defaultManager() 

do { 
    try fileManager.createDirectoryAtPath(storePath as String, withIntermediateDirectories: true, attributes: nil) 
} catch let error as NSError { 
    print("Error creating storePath \(storePath): \(error)") 
} 
let sqliteFilePath = storePath.stringByAppendingPathComponent(storeName + ".sqlite") 
return NSURL(fileURLWithPath: sqliteFilePath) 
     } 

     lazy var model : NSManagedObjectModel = NSManagedObjectModel(contentsOfURL: self.modelURL)! 

      var store : NSPersistentStore? 

       lazy var coordinator : NSPersistentStoreCoordinator = { 
let coordinator = NSPersistentStoreCoordinator(managedObjectModel: self.model) 
do { 
    self.store = try coordinator.addPersistentStoreWithType(
    NSSQLiteStoreType, 
    configuration: nil, 
    URL: self.storeURL, 
    options: self.options) 
} catch var error as NSError { 
    print("Store Error: \(error)") 
    self.store = nil 
} catch { 
    fatalError() 
} 
return coordinator 
    }() 

      lazy var context : NSManagedObjectContext = { 
let context = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType) 
context.persistentStoreCoordinator = self.coordinator 
return context 
     }() 
    } 

Answer 1

你的第一个代码片段创建一个管理对象上下文：

lazy var context : NSManagedObjectContext = { 
    let context = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType) 
    context.persistentStoreCoordinator = self.coordinator 
    return context 
}() 

你的第二个代码片段不会创建被管理对象上下文：

var managedObjectContext : NSManagedObjectContext? 
lazy var note: Note? = { 
    if let context = self.managedObjectContext { 
     return NSEntityDescription.insertNewObjectForEntityForName("Note", inManagedObjectContext: context) as? Note 
    } 
    return .None 
}() 

用斯威夫特可选展开到第二个片段检查self.managedObjectContext不是零。如果不是零，则将其分配给本地变量context。您不要在此处设置持久性存储协调器，因为您未创建托管对象上下文。此代码假定self.managedObjectContext已经在其他地方创建（可能位于第一个片段中）。

没有持久性存储协调器，托管对象上下文没有多大用处，您也无法对其执行任何有用的操作。你尤其不能用它保存数据。但是因为你的第二个代码片段不是创建一个托管对象上下文，所以在这里并不重要。