Come gestire le istanze temporanee di NSManagedObject?

Ho bisogno di creare NSManagedObjectistanze, fare alcune cose con esse e poi eliminarle o archiviarle su sqlite db. Il problema è che non posso creare istanze di NSManagedObjectnon connesso a NSManagedObjectContexte questo significa che devo chiarire in qualche modo dopo aver deciso che non ho bisogno di alcuni degli oggetti nel mio db.

Per affrontarlo, ho creato un archivio in memoria utilizzando lo stesso coordinatore e sto inserendo oggetti temporanei lì usando assignObject:toPersistentStore.Ora, come posso assicurarmi che questi oggetti temporanei non arrivino ai dati, che prendo dal comune a entrambi i negozi contesto? Oppure devo creare contesti separati per un'attività del genere?

UPD:

Ora sto pensando di creare un contesto separato per l'archivio in memoria. Come sposto gli oggetti da un contesto a un altro? Basta usare [context insertObject:]? Funzionerà bene in questa configurazione? Se inserisco un oggetto dal grafico degli oggetti, anche l'intero grafico viene inserito nel contesto?

NOTA: questa risposta è molto vecchia. Vedere i commenti per la cronologia completa. Da allora la mia raccomandazione è cambiata e non consiglio più di utilizzare NSManagedObjectistanze non associate . La mia raccomandazione attuale è di utilizzare NSManagedObjectContextistanze figlio temporanee .

Risposta originale

Il modo più semplice per farlo è creare le NSManagedObjectistanze senza un file NSManagedObjectContext.

NSEntityDescription *entity = [NSEntityDescription entityForName:@"MyEntity" inManagedObjectContext:myMOC];
NSManagedObject *unassociatedObject = [[NSManagedObject alloc] initWithEntity:entity insertIntoManagedObjectContext:nil];

Quindi, quando vuoi salvarlo:

[myMOC insertObject:unassociatedObject];
NSError *error = nil;
if (![myMoc save:&error]) {
  //Respond to the error
}

iOS5 fornisce un'alternativa più semplice alla risposta di Mike Weller. Utilizza invece un figlio NSManagedObjectContext. Elimina la necessità di trampolino attraverso NSNotificationCenter

Per creare un contesto figlio:

NSManagedObjectContext *childContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
childContext.parentContext = myMangedObjectContext;

Quindi crea i tuoi oggetti usando il contesto figlio:

NSManagedObject *o = [NSEntityDescription insertNewObjectForEntityForName:@"MyObject" inManagedObjectContext:childContext];

Le modifiche vengono applicate solo quando viene salvato il contesto figlio. Quindi per scartare le modifiche basta non salvare.

C'è ancora un limite alle relazioni. cioè non puoi creare relazioni con oggetti in altri contesti. Per aggirare questo problema, usa l'ID oggetto, per ottenere l'oggetto dal contesto figlio. per esempio.

NSManagedObjectID *mid = [myManagedObject objectID];
MyManagedObject *mySafeManagedObject = [childContext objectWithID:mid];
object.relationship=mySafeManagedObject;

Nota, il salvataggio del contesto figlio applica le modifiche al contesto padre. Il salvataggio del contesto genitore mantiene le modifiche.

Vedere la sessione 214 del wwdc 2012 per una spiegazione completa.

Il modo corretto per ottenere questo tipo di cose è con un nuovo contesto di oggetti gestiti. Si crea un contesto dell'oggetto gestito con lo stesso archivio persistente:

NSManagedObjectContext *tempContext = [[[NSManagedObjectContext alloc] init] autorelease];
[tempContext setPersistentStore:[originalContext persistentStore]];

Quindi aggiungi nuovi oggetti, li muti, ecc.

Quando arriva il momento di salvare, è necessario chiamare [tempContext save: ...] in tempContext e gestire la notifica di salvataggio per unirla al contesto originale. Per eliminare gli oggetti, rilascia questo contesto temporaneo e dimenticalo.

Quindi, quando salvi il contesto temporaneo, le modifiche vengono mantenute nello store e devi solo riportare quelle modifiche nel tuo contesto principale:

/* Called when the temp context is saved */
- (void)tempContextSaved:(NSNotification *)notification {
    /* Merge the changes into the original managed object context */
    [originalContext mergeChangesFromContextDidSaveNotification:notification];
}

// Here's where we do the save itself

// Add the notification handler
[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(tempContextSaved:)
                                             name:NSManagedObjectContextDidSaveNotification
                                           object:tempContext];

// Save
[tempContext save:NULL];
// Remove the handler again
[[NSNotificationCenter defaultCenter] removeObserver:self
                                                name:NSManagedObjectContextDidSaveNotification
                                              object:tempContext];

Questo è anche il modo in cui dovresti gestire le operazioni di dati di base multi-thread. Un contesto per thread.

Se devi accedere a oggetti esistenti da questo contesto temporaneo (per aggiungere relazioni, ecc.), Allora devi utilizzare l'ID dell'oggetto per ottenere una nuova istanza come questa:

NSManagedObject *objectInOriginalContext = ...;
NSManagedObject *objectInTemporaryContext = [tempContext objectWithID:[objectInOriginalContext objectID]];

Se provi a utilizzare un file NSManagedObject nel contesto sbagliato, otterrai delle eccezioni durante il salvataggio.

La creazione di oggetti temporanei da un contesto nullo funziona bene finché non si tenta effettivamente di avere una relazione con un oggetto il cui contesto! = Nil!

assicurati di essere d'accordo con quello.

Quello che stai descrivendo è esattamente a cosa NSManagedObjectContextserve.

Da Core Data Programming Guide: Core Data Basics

Puoi pensare a un contesto oggetto gestito come un blocco appunti intelligente. Quando si recuperano oggetti da un archivio persistente, si portano copie temporanee sul blocco appunti dove formano un oggetto grafico (o una raccolta di oggetti grafici). Puoi quindi modificare quegli oggetti come preferisci. A meno che non si salvi effettivamente tali modifiche, tuttavia, l'archivio persistente rimane inalterato.

E Guida alla programmazione dei dati di base: convalida degli oggetti gestiti

Ciò è anche alla base dell'idea di un contesto di oggetto gestito che rappresenta un "blocco appunti": in generale è possibile portare gli oggetti gestiti sul blocco appunti e modificarli come si desidera prima di eseguire il commit delle modifiche o di eliminarli.

NSManagedObjectContextsono progettati per essere leggeri. Puoi crearli e scartarli a piacimento: è il coordinatore dei negozi persistenti e le dipendenze che sono "pesanti". A un singolo coordinatore del negozio persistente possono essere associati molti contesti. Con il modello di confinamento dei thread più vecchio e obsoleto ciò significherebbe impostare lo stesso coordinatore del negozio persistente in ogni contesto. Oggi significherebbe connettere contesti nidificati a un contesto radice associato al coordinatore del negozio persistente.

Crea un contesto, crea e modifica gli oggetti gestiti all'interno di quel contesto. Se desideri mantenerli e comunicare tali modifiche, salva il contesto. Altrimenti scartalo.

Il tentativo di creare oggetti gestiti indipendenti da un NSManagedObjectContextrichiede problemi. Ricorda che Core Data è in definitiva un meccanismo di rilevamento delle modifiche per un oggetto grafico. Per questo motivo, gli oggetti gestiti fanno davvero parte del contesto degli oggetti gestiti . Il contesto osserva il loro ciclo di vita e senza il contesto non tutte le funzionalità degli oggetti gestiti funzioneranno correttamente.

A seconda dell'utilizzo dell'oggetto temporaneo, ci sono alcune avvertenze per le raccomandazioni di cui sopra. Il mio caso d'uso è che voglio creare un oggetto temporaneo e associarlo alle viste. Quando l'utente sceglie di salvare questo oggetto, desidero impostare le relazioni con gli oggetti esistenti e salvare. Voglio farlo per evitare di creare un oggetto temporaneo per contenere quei valori. (Sì, potrei solo aspettare che l'utente salvi e quindi prenda il contenuto della vista, ma sto inserendo queste viste all'interno di una tabella e la logica per farlo è meno elegante.)

Le opzioni per gli oggetti temporanei sono:

1) (Preferito) Crea l'oggetto temporaneo in un contesto figlio. Questo non funzionerà perché sto associando l'oggetto all'interfaccia utente e non posso garantire che le funzioni di accesso all'oggetto vengano chiamate nel contesto figlio. (Non ho trovato documentazione che dichiari diversamente, quindi devo presumere.)

2) Creare l'oggetto temporaneo con un contesto oggetto nullo. Questo non funziona e provoca perdita / danneggiamento dei dati.

La mia soluzione: ho risolto questo problema creando l'oggetto temporaneo con un contesto di oggetto nullo, ma quando salvo l'oggetto, invece di inserirlo come # 2, copio tutti i suoi attributi in un nuovo oggetto che creo nel contesto principale. Ho creato un metodo di supporto nella mia sottoclasse NSManagedObject chiamato cloneInto: che mi consente di copiare facilmente attributi e relazioni per qualsiasi oggetto.

Per me la risposta di Marcus non ha funzionato. Ecco cosa ha funzionato per me:

NSEntityDescription entityForName:@"MyEntity" inManagedObjectContext:myMOC];
NSManagedObject *unassociatedObject = [[NSManagedObject alloc] initWithEntity:entity insertIntoManagedObjectContext:nil];

quindi, se decido di salvarlo:

[myMOC insertObject:unassociatedObjet];
NSError *error = nil;
[myMoc save:&error];
//Check the error!

Inoltre, non dobbiamo dimenticare di rilasciarlo

[unassociatedObject release]

Sto riscrivendo questa risposta per Swift come tutte le domande simili per un rapido reindirizzamento a questa domanda.

È possibile dichiarare l'oggetto senza ManagedContext utilizzando il codice seguente.

let entity = NSEntityDescription.entity(forEntityName: "EntityName", in: myContext)
let unassociatedObject = NSManagedObject.init(entity: entity!, insertInto: nil)

Successivamente, per salvare l'oggetto è possibile inserirlo nel contesto e salvarlo.

myContext.insert(unassociatedObject)
// Saving the object
do {
    try self.stack.saveContext()
    } catch {
        print("save unsuccessful")
    }
}