删除/重新设置的所有条目中的核心数据？

Question

你知道的任何方式来删除所有条目，储存在核心数据？我的架构应该保持相同；我只是想要重置它的空白。

---

编辑

我想要做这种编程方式使用户基本上可以打一个 reset 按钮。

Answer 1

您仍可以删除该文件编程，使用的NSFileManager：removeItemAtPath ::方法

NSPersistentStore *store = ...;
NSError *error;
NSURL *storeURL = store.URL;
NSPersistentStoreCoordinator *storeCoordinator = ...;
[storeCoordinator removePersistentStore:store error:&error];
[[NSFileManager defaultManager] removeItemAtPath:storeURL.path error:&error];

然后，只需添加持久存储回以确保它正确地重新创建。

，用于通过每个实体迭代的编程方法是既慢且易于出错。做这种方式的用途是，如果你想删除一些实体，而不是别人。但是你仍然需要确保你保持引用完整性，否则您将无法坚持更改。

刚取出存储和重新创建既快速又安全，当然也可以在运行时程序来完成。

<强>更新的iOS5 +

通过引入外部二进制存储（allowsExternalBinaryDataStorage或储存在外部记录文件）在IOS 5和OS X 10.7，简单地删除由storeURLs指出文件是不够的。你会离开背后的外部记录文件。由于这些外部录像文件的命名方式是不公开的，我没有一个通用的解决方案呢。 - AN0 5月8 '12在23:00

Answer 2

您可以删除SQLite的文件 - 但我选择用一个单独的功能清除表做到这一点：

- (void) deleteAllObjects: (NSString *) entityDescription  {
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:entityDescription inManagedObjectContext:_managedObjectContext];
    [fetchRequest setEntity:entity];

    NSError *error;
    NSArray *items = [_managedObjectContext executeFetchRequest:fetchRequest error:&error];
    [fetchRequest release];


    for (NSManagedObject *managedObject in items) {
        [_managedObjectContext deleteObject:managedObject];
        DLog(@"%@ object deleted",entityDescription);
    }
    if (![_managedObjectContext save:&error]) {
        DLog(@"Error deleting %@ - error:%@",entityDescription,error);
    }

}

我选择了通过表格做表的原因是，它让我确认一下，因为我在做节目，删除该表的内容是明智的，没有，我宁愿保持数据。

做这这将是比慢得多只是删除文件，我将变成一个文件删除，如果我这种方法耗时过长。

Answer 3

iOS 10+ 的更新解决方案

使用 NSBatchDeleteRequest 删除实体中的所有对象，而无需将它们加载到内存中或迭代它们。

// create the delete request for the specified entity
let fetchRequest: NSFetchRequest<NSFetchRequestResult> = MyEntity.fetchRequest()
let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)

// get reference to the persistent container
let persistentContainer = (UIApplication.shared.delegate as! AppDelegate).persistentContainer

// perform the delete
do {
    try persistentContainer.viewContext.execute(deleteRequest)
} catch let error as NSError {
    print(error)
}

此代码已针对 iOS 10 和 Swift 3 进行了更新。如果您需要支持 iOS 9，请参阅 这个问题.

资料来源：

• 核心数据：删除实体的所有实例的最快方法 （包括 Objective-C 代码）
• 核心数据的新变化 （WWDC 2015 视频）
• 核心数据的新变化 （WWDC 2016 视频）
• 如何在 iOS 10 中使用核心数据
• Core Data Swift 3.0 的新增功能

Answer 4

我已经写了通过每一个店内走一段clearStores方法和从协调器和文件系统（错误处理搁置）删除它既：

NSArray *stores = [persistentStoreCoordinator persistentStores];

for(NSPersistentStore *store in stores) {
    [persistentStoreCoordinator removePersistentStore:store error:nil];
    [[NSFileManager defaultManager] removeItemAtPath:store.URL.path error:nil];
}

[persistentStoreCoordinator release], persistentStoreCoordinator = nil;

此方法是一种coreDataHelper类需要照顾（除其他外）内创建persistentStore当它是零。

Answer 5

予移除在HomeViewController类的按钮事件从核心数据的所有数据： 这篇文章帮了我这么多，我想我会做出贡献。

-(IBAction)buttonReset:(id)sender
{
    NSLog(@"buttonReset Pressed");

    //Erase the persistent store from coordinator and also file manager.
    NSPersistentStore *store = [self.persistentStoreCoordinator.persistentStores lastObject];
    NSError *error = nil;
    NSURL *storeURL = store.URL;
    [self.persistentStoreCoordinator removePersistentStore:store error:&error];
    [[NSFileManager defaultManager] removeItemAtURL:storeURL error:&error];


    NSLog(@"Data Reset");

    //Make new persistent store for future saves   (Taken From Above Answer)
    if (![self.persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) {
        // do something with the error
    }

}

请注意，为了调用self.persistentStoreCoordinator我宣布在主页视图控制器的属性。 （不要担心，我使用的保存和加载managedObjectContext。）

@property (nonatomic, retain) NSManagedObjectContext        *   managedObjectContext;
@property (nonatomic, retain) NSPersistentStoreCoordinator  *   persistentStoreCoordinator;

然后在AppDelegate中的applicationDidFinishLaunching正下方创建HomeViewController我有：

homeViewController = [[HomeViewController alloc] initWithNibName:@"HomeViewController" bundle:nil];
homeViewController.managedObjectContext = self.managedObjectContext;
homeViewController.persistentStoreCoordinator = self.persistentStoreCoordinator;

Answer 6

MagicalRecord 使这很容易。

[MyCoreDataObject MR_truncateAll];

Answer 7

iOS9 +，夫特2

删除所有实体的所有对象

func clearCoreDataStore() {
    let entities = managedObjectModel.entities
    for entity in entities {
        let fetchRequest = NSFetchRequest(entityName: entity.name!)
        let deleteReqest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
        do {
            try context.executeRequest(deleteReqest)
        } catch {
            print(error)
        }
    }
}

Answer 8

[对赏金要求较晚的答复，要求更新的答复]

看了之前的回答，

• 正如@Grouchal 和其他人所建议的那样，获取和删除所有项目仍然是一种有效且有用的解决方案。如果您有非常大的数据存储，那么它可能会很慢，但它仍然工作得很好。
• 正如您和@groundhog 所指出的，简单地删除数据存储不再有效。它已经过时了 即使您不使用外部二进制存储 因为 iOS 7 使用 WAL 模式进行 SQLite 日志记录。使用 WAL 模式，任何核心数据持久存储都可能存在（可能很大）日志文件。

但是有一种不同的、类似的方法来删除确实有效的持久存储。关键是将持久存储文件放在其自己的不包含任何其他内容的子目录中。不要只是将其粘贴在文档目录（或任何地方）中，而是为持久存储创建一个新的子目录。该目录的内容最终将成为持久存储文件、日志文件和外部二进制文件。如果您想破坏整个数据存储，请删除该目录，它们就会全部消失。

在设置持久性存储时，您可以执行以下操作：

NSURL *storeDirectoryURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"persistent-store"];
if ([[NSFileManager defaultManager] createDirectoryAtURL:storeDirectoryURL
        withIntermediateDirectories:NO
        attributes:nil
        error:nil]) {
    NSURL *storeURL = [storeDirectoryURL URLByAppendingPathComponent:@"MyApp.sqlite"];
    // continue with storeURL as usual...
}

然后当你想删除商店时，

[[NSFileManager defaultManager] removeItemAtURL:storeDirectoryURL error:nil];

这会递归地删除自定义子目录及其中的所有核心数据文件。

仅当您尚未将持久存储与其他重要数据放在同一文件夹中时，此方法才有效. 。就像文档目录一样，其中可能还有其他有用的东西。如果这是您的情况，您可以通过查找您想要的文件来获得相同的效果 做 想要保留并删除其他所有内容。就像是：

NSString *docsDirectoryPath = [[self applicationDocumentsDirectory] path];
NSArray *docsDirectoryContents = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:docsDirectoryPath error:nil];
for (NSString *docsDirectoryItem in docsDirectoryContents) {
    // Look at docsDirectoryItem. If it's something you want to keep, do nothing.
    // If it's something you don't recognize, remove it.
}

这种方法可能容易出错. 。你必须绝对确定你知道 每一个 您要保留的文件，因为否则您可能会删除重要数据。另一方面，您可以删除外部二进制文件，而无需实际知道用于存储它们的文件/目录名称。

Answer 9

如果您要删除的所有对象，不希望删除的后盾文件，可以使用下面的方法：

- (void)deleteAllObjectsInContext:(NSManagedObjectContext *)context
                       usingModel:(NSManagedObjectModel *)model
{
    NSArray *entities = model.entities;
    for (NSEntityDescription *entityDescription in entities) {
        [self deleteAllObjectsWithEntityName:entityDescription.name
                                   inContext:context];
    }
}

- (void)deleteAllObjectsWithEntityName:(NSString *)entityName
                             inContext:(NSManagedObjectContext *)context
{
    NSFetchRequest *fetchRequest =
        [NSFetchRequest fetchRequestWithEntityName:entityName];
    fetchRequest.includesPropertyValues = NO;
    fetchRequest.includesSubentities = NO;

    NSError *error;
    NSArray *items = [context executeFetchRequest:fetchRequest error:&error];

    for (NSManagedObject *managedObject in items) {
        [context deleteObject:managedObject];
        NSLog(@"Deleted %@", entityName);
    }
}

要注意的是它可能会很慢（取决于有多少对象是在你的对象图）。

Answer 10

下面是用于净化核心数据合并的溶液。

- (void)deleteAllObjectsInCoreData
{
    NSArray *allEntities = self.managedObjectModel.entities;
    for (NSEntityDescription *entityDescription in allEntities)
    {
        NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
        [fetchRequest setEntity:entityDescription];

        fetchRequest.includesPropertyValues = NO;
        fetchRequest.includesSubentities = NO;

        NSError *error;
        NSArray *items = [self.managedObjectContext executeFetchRequest:fetchRequest error:&error];

        if (error) {
                NSLog(@"Error requesting items from Core Data: %@", [error localizedDescription]);
            }

        for (NSManagedObject *managedObject in items) {
            [self.managedObjectContext deleteObject:managedObject];
        }

        if (![self.managedObjectContext save:&error]) {
            NSLog(@"Error deleting %@ - error:%@", entityDescription, [error localizedDescription]);
        }
    }  
}

Answer 11

如果你想要去的删除所有的对象路线（这比拆了核心数据堆栈要简单得多，但较少高性能），比这更好的实现：

- (void)deleteAllManagedObjectsInModel:(NSManagedObjectModel *)managedObjectModel context:(NSManagedObjectContext *)managedObjectContext
{
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        [managedObjectContext performBlockAndWait:^{
            for (NSEntityDescription *entity in managedObjectModel) {
                NSFetchRequest *fetchRequest = [NSFetchRequest new];
                [fetchRequest setEntity:entity];
                [fetchRequest setIncludesSubentities:NO];
                NSArray *objects = [managedObjectContext executeFetchRequest:fetchRequest error:nil];
                for (NSManagedObject *managedObject in objects) {
                    [managedObjectContext deleteObject:managedObject];
                }            
            }

            [managedObjectContext save:nil];
        }];
    }];
    [operation setCompletionBlock:^{
        // Do stuff once the truncation is complete
    }];
    [operation start];
}

此实施利用NSOperation执行删除掉主螺纹的，并通知上完成。你可能想发出完成块以泡沫的状态返回到主线程内的通知或东西。

Answer 12

的iOS 10 +夫特3溶液：

func clearCoreDataStore() {
    let delegate = UIApplication.shared.delegate as! AppDelegate
    let context = delegate.persistentContainer.viewContext

    for i in 0...delegate.persistentContainer.managedObjectModel.entities.count-1 {
        let entity = delegate.persistentContainer.managedObjectModel.entities[i]

        do {
            let query = NSFetchRequest<NSFetchRequestResult>(entityName: entity.name!)
            let deleterequest = NSBatchDeleteRequest(fetchRequest: query)
            try context.execute(deleterequest)
            try context.save()

        } catch let error as NSError {
            print("Error: \(error.localizedDescription)")
            abort()
        }
    }
}

通过所有的核心数据实体的迭代，并清除它们

Answer 13

下面是用于自AppDelegate中并且留出前额定答案的代码的最后位少的呼叫的略微简化的版本。我也得到了一个错误“对象的持久性存储是不是从这个NSManagedObjectContext中的协调可达”，所以只需要补充一点回来。

NSPersistentStoreCoordinator *storeCoordinator = [self persistentStoreCoordinator];
NSPersistentStore *store = [[storeCoordinator persistentStores] lastObject];
NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"dataModel"];
NSError *error;

[storeCoordinator removePersistentStore:store error:&error];
[[NSFileManager defaultManager] removeItemAtPath:storeURL.path error:&error];

[_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error];

if (storeCoordinator != nil) {
    _managedObjectContext = [[NSManagedObjectContext alloc] init];
    [_managedObjectContext setPersistentStoreCoordinator:storeCoordinator];
}

Answer 14

迅速溶液：

class func deleteAllManagedObjects() {

        let modelURL = NSBundle.mainBundle().URLForResource("some string", withExtension: "mom")
        let mom = NSManagedObjectModel(contentsOfURL: modelURL)

        for entityName in mom.entitiesByName.keys {
            let fr = NSFetchRequest(entityName: entityName as String)
            let a = Utility.managedObjectContext().executeFetchRequest(fr, error: nil) as [NSManagedObject]
            for mo in a {
                Utility.managedObjectContext().deleteObject(mo)
            }
        }

        Utility.managedObjectContext().save(nil)
    }

Answer 15

作为快速参考，以节省搜索别处 - 删除它是可以做到的重建后的持久性存储：

if (![persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) {
// do something with the error
}

Answer 16

感谢您的职位。我跟着它，它为我工作。但我有没有在任何的答复中提到的另一个问题。所以，我不知道这是否只是我。

总之，以为我会在这里发表的问题，我的方式解决它。

我在数据库中的一些记录，我想清除一切干净之前写入新的数据到数据库，所以我所做的一切，包括

[[NSFileManager defaultManager] removeItemAtURL:storeURL error:&error]; 

和然后用于managedObjectContext（现在应该是空的）来访问数据库，以某种方式将数据仍然存在。 一段时间后故障排除，我发现我需要重置managedObjectContext，managedObject，managedObjectModel和 persistentStoreCoordinator，以前我用managedObjectContext访问dabase。现在我有一个干净的数据库写入。

Answer 17

若干好这个问题的答案。这里是一个不错的简洁之一。前两行删除SQLite数据库。然后，为：循环删除在managedObjectContext存储器中的任何对象

NSURL *storeURL = [[(FXYAppDelegate*)[[UIApplication sharedApplication] delegate] applicationDocumentsDirectory] URLByAppendingPathComponent:@"AppName.sqlite"];
[[NSFileManager defaultManager] removeItemAtURL:storeURL error:nil];
for (NSManagedObject *ct in [self.managedObjectContext registeredObjects]) {
    [self.managedObjectContext deleteObject:ct];
}

Answer 18

您也可以找到所有的实体名称，并通过名称删除它们。其较长的版本，但效果很好，你不要这样有持久性存储工作

 - (void)clearCoreData
{
NSError *error;
NSEntityDescription *des = [NSEntityDescription entityForName:@"Any_Entity_Name" inManagedObjectContext:_managedObjectContext];
NSManagedObjectModel *model = [des managedObjectModel];
NSArray *entityNames = [[model entities] valueForKey:@"name"];

for (NSString *entityName in entityNames){

    NSFetchRequest *deleteAll = [NSFetchRequest fetchRequestWithEntityName:entityName];
    NSArray *matches = [self.database.managedObjectContext executeFetchRequest:deleteAll error:&error];

}
    if (matches.count > 0){
        for (id obj in matches){

            [_managedObjectContext deleteObject:obj];
        }
       [self.database.managedObjectContext save:&error];
    }
}

有关“Any_Entity_Name”只是给你的实体名称中的任何一个，我们只需要弄清楚的实体描述你的实体之内。 ValueForKey @“名”将返回所有的实体名称。最后，不要忘记保存。

Answer 19

所接受的答案是正确的消除URL通过NSFileManager是正确的，但正如在iOS5+编辑、持久储存是不表示只有通过一个文件。对于源码存储的*.源码,*.源码-shm和*。源码-沃尔...幸运的是，由于iOS7+我们可以使用的方法

[NSPersistentStoreCoordinator +removeUbiquitousContentAndPersistentstoreaturl：选项：错误：]

照顾的去除，因此该代码应是这样的：

NSPersistentStore *store = ...;
NSError *error;
NSURL *storeURL = store.URL;
NSString *storeName = ...;
NSPersistentStoreCoordinator *storeCoordinator = ...;
[storeCoordinator removePersistentStore:store error:&error];
[NSPersistentStoreCoordinator removeUbiquitousContentAndPersistentStoreAtURL:storeURL.path options:@{NSPersistentStoreUbiquitousContentNameKey: storeName} error:&error];

Answer 20

与所有版本。通过实体名称和遍历，删除所有条目，并保存的上下文。

func deleteData(entityToFetch: String, completion: @escaping(_ returned: Bool) ->()) {
    var context = NSManagedObjectContext()
    if #available(iOS 10.0, *) {
        context = self.persistentContainer.viewContext
    } else {
        context = self.managedObjectContext
    }

    let fetchRequest = NSFetchRequest<NSFetchRequestResult>()
    fetchRequest.entity = NSEntityDescription.entity(forEntityName: entityToFetch, in: context)
    fetchRequest.includesPropertyValues = false
    do {
        let results = try context.fetch(fetchRequest) as! [NSManagedObject]
        for result in results {
            context.delete(result)
        }
        try context.save()
        completion(true)
    } catch {
        completion(false)
        print("fetch error -\(error.localizedDescription)")
    }
}

Answer 21

下面是删除所有记录在你拥有的每表版本。

<强>夫特4

static func resetDatabase() {
    do {
        try dataStore.persistentStoreCoordinator.managedObjectModel.entities.forEach { (entity) in
            if let name = entity.name {
                let fetch = NSFetchRequest<NSFetchRequestResult>(entityName: name)
                let request = NSBatchDeleteRequest(fetchRequest: fetch)
                try mainContext.execute(request)
            }
        }

        try mainContext.save()
    } catch {
        print("error resenting the database: \(error.localizedDescription)")
    }
}

Answer 22

删除持久性存储文件和设置一个新的持久存储协调器？

Answer 23

从fileURLPath删除SQLite和再建。

Answer 24

假设你正在使用MagicalRecord并且具有默认持久存储：

我不喜欢承担一定的文件存在和/或要求进入实体名称或类别的所有解决方案。这是删除所有实体的所有数据斯威夫特（2），安全的方式。删除后，它会重新建立一个新的堆栈太（我其实不知道为这部分如何neccessery是）。

这是戈多当你想删除一切，但有一个工作商店和建设部在获取新数据“注销”风格的情况下（在一次用户登录...）

extension NSManagedObject {

    class func dropAllData() {

        MagicalRecord.saveWithBlock({ context in

            for name in NSManagedObjectModel.MR_defaultManagedObjectModel().entitiesByName.keys {
                do { try self.deleteAll(name, context: context) }
                catch { print("⚠️ ✏️ Error when deleting \(name): \(error)") }
            }

            }) { done, err in
                MagicalRecord.cleanUp()
                MagicalRecord.setupCoreDataStackWithStoreNamed("myStoreName")
        }
    }

    private class func deleteAll(name: String, context ctx: NSManagedObjectContext) throws {
        let all = NSFetchRequest(entityName: name)
        all.includesPropertyValues = false

        let allObjs = try ctx.executeFetchRequest(all)
        for obj in allObjs {
            obj.MR_deleteEntityInContext(ctx)
        }

    }
}

Answer 25

使用此

+(NSArray *)fetchDataFromEntity:(NSString *)entityName context:(NSManagedObjectContext *)context
{
    NSFetchRequest * fetchRequest =[[NSFetchRequest alloc] init];
    NSEntityDescription * CategoriesEntity = [NSEntityDescription entityForName:entityName inManagedObjectContext:context];
    [fetchRequest setEntity:CategoriesEntity];

    NSError * error;
    NSInteger count = [context countForFetchRequest:fetchRequest error:&error];

    if (count && count>0) {

        NSArray * fetchedObjects = [context executeFetchRequest:fetchRequest error:&error];
        if (fetchedObjects && fetchedObjects.count>0) {

            return fetchedObjects;
        }else
            return nil;

    }
    else
        return nil;
}
+ (void)deleteObjectsOfArray:(NSMutableArray*)ary context:(NSManagedObjectContext *)context {
    for (NSManagedObject * obj in ary) {
        [context deleteObject:obj];
    }
    NSError *saveError = nil;
    [context save:&saveError];
}
+ (void)deleteEntity:(NSString *)entityName context:(NSManagedObjectContext *)context {
    NSArray *listArray = [self fetchDataFromEntity:entityName context:context];
    [self deleteObjectsOfArray:[NSMutableArray arrayWithArray:listArray] context:context];
}

Answer 26

我把Grouchal的代码，并加快步伐我用枚举并发模式（NSEnumerationConcurrent），它相比于环（在我的应用程序添加此功能对于测试人员，使他们能够清晰的数据做测试用例有一点快而不是删除和安装应用程序）

- (void)resetObjects
{
    [self deleteAllObjectsInEntity:@"Entity1"];
    [self deleteAllObjectsInEntity:@"Entity2"];
    [self deleteAllObjectsInEntity:@"Entity3"];
    [self deleteAllObjectsInEntity:@"Entity4"];
}

-(void) deleteAllObjectsInEntity:(NSString*) entityName
{
    MainDataContext *coreDataContext = [MainDataContext sharedInstance];
    NSManagedObjectContext *currentContext = coreDataContext.managedObjectContext;
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:entityName inManagedObjectContext:currentContext];
    [fetchRequest setEntity:entity];

    NSError *error;
    NSArray *items = [currentContext executeFetchRequest:fetchRequest error:&error];

    [items enumerateObjectsWithOptions:NSEnumerationConcurrent usingBlock:^(NSManagedObject * obj, NSUInteger idx, BOOL *stop) {
        [currentContext deleteObject:obj];
    }];


    if (![currentContext save:&error]) {
        NSLog(@"Error deleting %@ - error:%@",entityName,error);
    }
}

Answer 27

在这里我swift3版本删除所有记录。 “用户”是实体名称

@IBAction func btnDelAll_touchupinside(_ sender: Any) {

    let appDelegate = UIApplication.shared.delegate as! AppDelegate
    let managedObjectContext = appDelegate.persistentContainer.viewContext

    let fetchReq = NSFetchRequest<NSFetchRequestResult>(entityName: "Users")
    let req = NSBatchDeleteRequest(fetchRequest: fetchReq)

    do {
        try managedObjectContext.execute(req)

    } catch {
        // Error Handling
    }   
}

Answer 28

的iOS 10和夫特3

假设你的实体名称为“照片”，并创建一个CoreDataStack类...

 func clearData() {
        do {            
            let context = CoreDataStack.sharedInstance.persistentContainer.viewContext
            let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: "Photo")
            do {
                let objects  = try context.fetch(fetchRequest) as? [NSManagedObject]
                _ = objects.map{$0.map{context.delete($0)}}
                CoreDataStack.sharedInstance.saveContext()
            } catch let error {
                print("ERROR DELETING : \(error)")
            }
        }
    }

下面是如何使用CoreData和如何使用此方法的很好的教程。 HTTPS ：//medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step-by-step-fb58fc6ce16f#.1tu6kt8qb

Answer 29

一种其它方法（除了删除批量要求）我经常使用（基于应用要求）是复位持久存储中。实施看起来是这样的iOS 10+和斯威夫特（假设你有一个CoreDataManager类）：

let persistentContainer: NSPersistentContainer = {
    let container = NSPersistentContainer(name: "<Data-Model-Name>“)
    container.loadPersistentStores(completionHandler: { (storeDescription, err) in
        if let err = err {
            fatalError("loading of store failed: \(err)")
        }
    })
    return container
}()

func resetPersistentStore() {

    if let persistentStore = persistentContainer.persistentStoreCoordinator.persistentStores.last {
        let storeURL = persistentContainer.persistentStoreCoordinator.url(for: persistentStore)

        do {
            try persistentContainer.persistentStoreCoordinator.destroyPersistentStore(at: storeURL, ofType: NSSQLiteStoreType, options: nil)
        } catch {
            print("failed to destroy persistent store:", error.localizedDescription)
        }

        do {
            try persistentContainer.persistentStoreCoordinator.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: storeURL, options: nil)
        } catch {
            print("failed to re-add persistent store:", error.localizedDescription)
        }
    }

}

该方法的一个优点是，它是更直接的尤其是当你有数据记录的加载在核心数据众多实体。在这种情况下的删除批量要求将是存储器密集型的。

Answer 30

你们都使这个看起来很复杂。您只需将您的NSManagedObjectContext复位方法