Você conhece alguma maneira de excluir todas as entradas armazenadas no Core Data? Meu esquema deve permanecer o mesmo; Eu só quero redefini-lo em branco.

Editar

Estou procurando fazer isso programaticamente, para que um usuário possa essencialmente pressionar um resetbotão.

Você ainda pode excluir o arquivo programaticamente, usando o método NSFileManager: removeItemAtPath ::.

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

Em seguida, adicione novamente o armazenamento persistente para garantir que ele seja recriado corretamente.

A maneira programática de iterar através de cada entidade é mais lenta e propensa a erros. O uso para fazer dessa maneira é se você deseja excluir algumas entidades e outras não. No entanto, você ainda precisa garantir a integridade referencial ou não poderá persistir nas alterações.

Apenas remover a loja e recriá-la é rápido e seguro, e certamente pode ser feito programaticamente em tempo de execução.

Atualização para iOS5 +

Com a introdução do armazenamento binário externo (permiteExternalBinaryDataStorage ou Store in External Record File) no iOS 5 e OS X 10.7, simplesmente excluir arquivos apontados por storeURLs não é suficiente. Você deixará os arquivos de registro externos para trás. Como o esquema de nomeação desses arquivos de registro externos não é público, ainda não tenho uma solução universal. - an0 8 / mai / 12 às 23:00

Você pode excluir o arquivo SQLite - mas eu escolho fazê-lo limpando as tabelas individualmente com as seguintes funções:

- (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);
    }

}

A razão pela qual escolhi fazê-lo tabela por tabela é que isso me faz confirmar, enquanto estou fazendo a programação, que a exclusão do conteúdo da tabela é sensata e não há dados que eu prefira manter.

Fazer isso será muito mais lento do que apenas excluir o arquivo e mudarei para uma exclusão de arquivo se esse método demorar muito.

Solução atualizada para iOS 10+

Use NSBatchDeleteRequestpara excluir todos os objetos na entidade sem precisar carregá-los na memória ou iterá-los.

// 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)
}

Este código foi atualizado para iOS 10 e Swift 3. Se você precisar oferecer suporte ao iOS 9, consulte esta pergunta .

Fontes:

• Dados principais: maneira mais rápida de excluir todas as instâncias de uma entidade (inclui código Objective-C)
• O que há de novo nos dados principais (vídeo da WWDC 2015)
• O que há de novo nos dados principais (vídeo da WWDC 2016)
• Como usar os dados principais no iOS 10
• O que há de novo no Core Data Swift 3.0

Escrevi um clearStoresmétodo que percorre todas as lojas e o excluo do coordenador e do sistema de arquivos (tratamento de erros deixado de lado):

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;

Esse método está dentro de uma coreDataHelperclasse que cuida (entre outras coisas) da criação do persistentStore quando é nulo.

Eu removo todos os dados dos dados principais de um evento de botão em uma classe HomeViewController: Este artigo me ajudou tanto que achei que contribuiria.

-(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
    }

}

Observe que, para chamar self.persistentStoreCoordinator, declarei uma propriedade no Home View Controller. (Não se preocupe com o managedObjectContext que eu uso para salvar e carregar.)

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

Em seguida, no AppDelegate ApplicationDidFinishLaunching logo abaixo, crie um HomeViewController que tenho:

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

O MagicalRecord torna isso muito fácil.

[MyCoreDataObject MR_truncateAll];

iOS9 +, Swift 2

Excluir todos os objetos em todas as entidades

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)
        }
    }
}

[Resposta tardia em resposta a uma recompensa pedindo respostas mais recentes]

Examinando respostas anteriores,

• Buscar e excluir todos os itens, conforme sugerido por @Grouchal e outros, ainda é uma solução eficaz e útil. Se você tiver armazenamentos de dados muito grandes, pode ser lento, mas ainda funciona muito bem.
• Simplesmente remover o armazenamento de dados é, como você e o @groundhog observam, não é mais eficaz. É obsoleto mesmo se você não usar armazenamento binário externo, porque o iOS 7 usa o modo WAL para diário de SQLite. No modo WAL, pode haver arquivos de diário (potencialmente grandes) disponíveis para qualquer armazenamento persistente do Core Data.

Mas há uma abordagem diferente e semelhante para remover o armazenamento persistente que funciona. A chave é colocar seu arquivo de armazenamento persistente em seu próprio subdiretório que não contém mais nada. Não o cole no diretório de documentos (ou em qualquer outro lugar), crie um novo subdiretório apenas para o armazenamento persistente. O conteúdo desse diretório acabará sendo o arquivo de armazenamento persistente, os arquivos de diário e os arquivos binários externos. Se você quiser destruir o repositório de dados inteiro, exclua esse diretório e todos eles desaparecerão.

Você faria algo assim ao configurar sua loja persistente:

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...
}

Então, quando você quis remover a loja,

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

Isso remove recursivamente o subdiretório personalizado e todos os arquivos de dados principais nele.

Isso funciona apenas se você ainda não possui seu armazenamento persistente na mesma pasta que outros dados importantes . Como o diretório de documentos, que provavelmente possui outras coisas úteis. Se essa é a sua situação, você pode obter o mesmo efeito, procurando por arquivos que você não deseja manter e remover tudo o resto. Algo como:

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.
}

Essa abordagem pode estar sujeita a erros . Você precisa ter certeza absoluta de que conhece todos os arquivos que deseja manter, pois, caso contrário, poderá remover dados importantes. Por outro lado, você pode remover os arquivos binários externos sem saber o nome do arquivo / diretório usado para armazená-los.

Aqui está a solução combinada para limpar os Dados Principais.

- (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]);
        }
    }  
}

Se você deseja excluir todos os objetos e não deseja excluir os arquivos de backup, pode usar os seguintes métodos:

- (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);
    }
}

Cuidado, pois pode ser muito lento (depende de quantos objetos estão no seu gráfico de objetos).

Se você deseja ir para a rota excluir todos os objetos (que é muito mais simples do que derrubar a pilha de dados principais, mas com menos desempenho), é uma implementação melhor:

- (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];
}

Essa implementação aproveita NSOperationa exclusão do encadeamento principal e a notificação na conclusão. Convém emitir uma notificação ou algo dentro do bloco de conclusão para retornar o status ao segmento principal.

Solução iOS 10 + Swift 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()
        }
    }
}

Repete todas as entidades de dados principais e as limpa

Obrigado pelo post. Eu o segui e funcionou para mim. Mas tive outro problema que não foi mencionado em nenhuma das respostas. Então, eu não tenho certeza se era apenas eu.

Enfim, pensei em postar aqui o problema e meu jeito de resolvê-lo.

Eu tinha alguns registros no banco de dados, queria limpar tudo antes de gravar novos dados no banco de dados, então fiz tudo, incluindo

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

e então usado managedObjectContextpara acessar o banco de dados (que deveria estar vazio agora), de alguma forma os dados ainda estavam lá. Depois de um tempo de resolução de problemas, eu descobri que eu preciso redefinir managedObjectContext, managedObject, managedObjectModele persistentStoreCoordinator, antes de eu usar managedObjectContextpara acessar o dabase. Agora eu tenho um banco de dados limpo para escrever.

Aqui está uma versão um pouco simplificada, com menos chamadas para o AppDelegate e o último pedaço de código que foi deixado de fora da resposta mais votada. Também estava recebendo um erro "O armazenamento persistente do objeto não está acessível a partir deste coordenador do NSManagedObjectContext", portanto, era necessário apenas adicioná-lo novamente.

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];
}

solução rápida:

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)
    }

Como uma referência rápida para salvar a pesquisa em outro lugar - recriar o armazenamento persistente após a exclusão pode ser feito com:

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

Várias boas respostas para esta pergunta. Aqui está um bom e conciso. As duas primeiras linhas excluem o banco de dados sqlite. Em seguida, o loop for: exclui todos os objetos na memória 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];
}

você também pode encontrar todos os nomes de entidades e excluí-los por nome. É uma versão mais longa, mas funciona bem, assim você não precisa trabalhar com armazenamento de persistência

 - (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];
    }
}

para "Any_Entity_Name" forneça apenas o nome da sua entidade, precisamos apenas descobrir a descrição da entidade em que elas estão. ValueForKey @ "name" retornará todos os nomes de entidade. Finalmente, não se esqueça de salvar.

A resposta aceita está correta, com a remoção do URL pelo NSFileManager, mas conforme declarado na edição iOS 5+, o armazenamento persistente não é representado apenas por um arquivo. Para a loja SQLite, é * .sqlite, * .sqlite-shm e * .sqlite-wal ... felizmente, desde o iOS 7+, podemos usar o método

[NSPersistentStoreCoordinator + removeUbiquitousContentAndPersistentStoreAtURL: opções: erro:]

para cuidar da remoção, então o código deve ser algo como isto:

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];

Aqui está uma versão que exclui todos os registros em todas as tabelas que você possui.

Swift 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)")
    }
}

Swift 4/5, iOS 9 ou superior

A reconstrução de todo o CoreDataarquivo SQLite garantirá que todos os dados sejam apagados, portanto, todas as entidades serão excluídas. Basta ligar deleteAndRebuild().

class CoreDataStack {
    // Change this
    static let datamodelName = "ProjectName"
    static let storeType = "sqlite"

    static let persistentContainer = NSPersistentContainer(name: datamodelName)
    private static let url: URL = {
        let url = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0].appendingPathComponent("\(datamodelName).\(storeType)")

        assert(FileManager.default.fileExists(atPath: url.path))

        return url
    }()

    static func loadStores() {
        persistentContainer.loadPersistentStores(completionHandler: { (nsPersistentStoreDescription, error) in
            if let error = error {
                fatalError(error.localizedDescription)
            }
        })
    }

    static func deleteAndRebuild() {
        try! persistentContainer.persistentStoreCoordinator.destroyPersistentStore(at: url, ofType: storeType, options: nil)

        loadStores()
    }
}

Funciona com todas as versões. Passe o nome da entidade e percorra para excluir todas as entradas e salvar o contexto.

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)")
    }
}

Um outro método (além de uma solicitação de exclusão em lote) que geralmente uso (com base nos requisitos do aplicativo) é redefinir o armazenamento persistente. A implementação é assim para iOS 10+ e Swift (supondo que você tenha uma classe 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)
        }
    }

}

Uma vantagem desse método é que é mais direto, especialmente quando você tem um monte de registros de dados para várias entidades em seus dados principais. Nesse caso, uma solicitação de exclusão em lote exigiria muita memória.

Solução Swift 5.1

public static func reset() {
    let coordinator = _persistentContainer.persistentStoreCoordinator
    for store in coordinator.persistentStores where store.url != nil {
        try? coordinator.remove(store)
        try? FileManager.default.removeItem(atPath: store.url!.path)
    }
}

Excluir o arquivo de armazenamento persistente e configurar um novo coordenador de armazenamento persistente?

Exclua o sqlite do seu fileURLPath e construa.

Supondo que você esteja usando MagicalRecorde tenha um armazenamento de persistência padrão:

Não gosto de todas as soluções que supõem que certos arquivos existem e / ou exigem a inserção de nomes ou classes de entidades. Esta é uma maneira rápida e segura de excluir todos os dados de todas as entidades. Após a exclusão, ele também recriará uma pilha nova (na verdade, não tenho certeza de quão necessário é essa parte).

É ideal para situações no estilo "logout" quando você deseja excluir tudo, mas possui um repositório de trabalho e um moc para obter novos dados (uma vez que o usuário efetua login ...)

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)
        }

    }
}

Usa isto

+(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];
}

Peguei o código de Grouchal e, para acelerar, usei a enumeração no modo simultâneo ( NSEnumerationConcurrent), ficou um pouco mais rápido em comparação ao loop for (no meu aplicativo, adicionei esse recurso aos testadores para que eles possam limpar dados e fazer testes, em vez de excluir e instalar aplicativo)

- (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);
    }
}

aqui minha versão swift3 para excluir todos os registros. 'Usuários' é o nome da entidade

@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
    }   
}