Share
Magical Record, creato da Saul Mora, è una libreria open-source che rende il lavoro con Core Data più semplice e più elegante. La libreria è stata ispirata dal pattern di registrazione attivo che si trova anche in Ruby on Rails. Questo tutorial ti insegnerà come usare Magical Record nelle tue app!
Quindi, perché Magical Record? Se hai sviluppato per iOS o OS X per qualche tempo, è probabile che tu abbia avuto un assaggio di Core Data. Ciò significa che sai che può essere un po 'complicato impostare uno stack di Core Data e, per essere onesti, lavorare con Core Data può essere un po' complesso, principalmente a causa della sua sintassi prolissa. Ad esempio, il recupero dei dati da un archivio persistente è piuttosto prolisso, soprattutto se confrontato con il modo in cui un'applicazione Ruby on Rails gestisce questa attività.
Anche se Magical Record semplifica il lavoro con Core Data, è fondamentale avere una buona conoscenza dei Core Data se si decide di utilizzarlo in un progetto. Nonostante il suo nome, Magical Record non esegue alcuna magia dietro le quinte che rende i Core Data funzionare in modo diverso. In altre parole, se ci si imbatte in problemi a un certo punto, è fondamentale comprendere come i dati di base funzionino internamente in modo da poter risolvere eventuali problemi che potrebbero comparire lungo il percorso.
Dall'introduzione di Magical Record, i requisiti sono stati aumentati a iOS 5.0 (o successivi) o OS X 10.7 (o successivi). Vale anche la pena ricordare che Magical Record supporta ARC out of the box.
Il modo migliore per mostrare ciò che Magical Record ha da offrire è creare un'applicazione che faccia uso di questa fantastica libreria. Ti mostrerà quanto è facile iniziare con Magical Record e, partendo da zero, ti mostrerà cosa è coinvolto nella creazione di un progetto con Core Data e Magical Record. L'applicazione che stiamo per creare è una semplice applicazione per prendere appunti in cui l'utente può creare, aggiornare ed eliminare note: un buon candidato per i dati principali.
Dal momento che hai letto fino a questo punto, presumo che tu abbia familiarità con lo sviluppo di iOS e abbia una conoscenza di base dei Core Data. In questo articolo, mi concentrerò principalmente sull'aspetto Core Data dell'applicazione, il che significa che non discuterò in dettaglio ogni frammento di codice.
Inizia creando un nuovo progetto basato sul Applicazione vista singola modello (figura 1) e nominarlo Note Magiche (figura 2). Imposta la famiglia di dispositivi su i phone e abilitare ARC selezionando la casella di controllo etichettata Utilizzare il conteggio di riferimento automatico. Non useremo Storyboard o Test unitari in questo tutorial.
Poiché utilizzeremo Core Data in questo progetto, non dimenticare di collegare il tuo progetto al framework Core Data. Poiché questo è un tutorial più avanzato, presumo che tu sappia già come farlo.
Aggiungere la libreria Magical Record al tuo progetto non richiede alcuna magia. Scarica l'ultima versione da GitHub, apri l'archivio e trascina la cartella denominata MagicalRecord nel tuo progetto Xcode. Assicurati di copiare anche i contenuti della cartella nel tuo progetto selezionando la casella di controllo Copia gli elementi nella cartella del gruppo di destinazione (se necessario) e non dimenticare di aggiungere la libreria Magical Record al target delle Note Magiche (figura 3). Un approccio alternativo per aggiungere Magical Record al tuo progetto è usare CocoaPods.
Per utilizzare Magical Record nelle classi, è necessario importare un file di intestazione, CoreData + MagicalRecord.h. Tuttavia, dato che useremo Magical Record un po 'in questo tutorial, è molto più comodo spostare questa istruzione import nel tuo progetto Prefix.pch file invece. Ciò assicurerà che Magical Record sia disponibile in ogni classe del tuo progetto.
Per impostazione predefinita, tutti i metodi Magical Record sono preceduti da SIG_. Puoi omettere il SIG_ prefisso aggiungendo una riga in più al progetto Prefix.pch file, # definisce MR_SHORTHAND. È importante aggiungere questa riga prima di importare il file di intestazione Magical Record.
// // Intestazione prefisso per tutti i file sorgente della destinazione "Note magiche" nel progetto "Note magiche" // #import#ifndef __IPHONE_4_0 #warning "Questo progetto utilizza funzionalità disponibili solo in iOS SDK 4.0 e versioni successive." #endif #ifdef __OBJC__ #import #importare #define MR_SHORTHAND #import "CoreData + MagicalRecord.h" #endif
Prima di configurare lo stack di Core Data, è necessario creare un modello Core Data. Il modello Core Data per questo progetto è semplice in quanto è costituito da una sola entità chiamata Nota. Il Nota l'entità ha quattro attributi, Data, titolo, corpo, e parole chiave. Titolo, corpo e parole chiave sono di tipo stringa, mentre la data è di tipo Data.
Inizia creando un nuovo modello di Core Data e nominalo MagicalNotes (figura 4). Crea il Nota entità e aggiungere i quattro attributi come descritto sopra (figura 5).
Prima di andare avanti, dobbiamo creare una custom NSManagedObject sottoclasse per il Nota entità. Questo è importante dal momento che Magical Record aggiunge un numero di metodi di classe utili a NSManagedObject classe, che renderà il lavoro con il Nota entità molto più facile, come vedrete in pochi minuti. Seleziona il Nota entità nel modello Core Data, creare un nuovo file, selezionare il Dati principali scheda a sinistra e scegliere il Sottoclasse NSManagedObject opzione a destra (figura 6).
L'impostazione di uno stack di Core Data richiede molto lavoro se non si utilizza uno dei modelli Xcode forniti. Con Magical Record, tuttavia, questo non è il caso. Dirigetevi verso il applicazione: didFinishLaunchingWithOptions: metodo della tua applicazione delegare e aggiungere il seguente snippet di codice.
[MagicalRecord setupCoreDataStack];
Questo è tutto ciò che c'è da fare. Per impostazione predefinita, il nome del negozio creato da Magical Record per te è identico al nome dell'applicazione. Tuttavia, puoi personalizzare il nome del negozio invocando setupCoreDataStackWithStoreNamed: invece e passando il nome del negozio.
Dietro le quinte, Magical Record istanzia un contesto di oggetti gestiti sul thread principale, nonché un coordinatore di archivio permanente e un modello di oggetti gestito. Quanto è magico questo?
Registrazione: La capacità di registrare i messaggi e gli errori di Core Data sulla console è incorporata in Magical Record. Dai un'occhiata alla console dopo aver creato e eseguito la tua applicazione per la prima volta. I log nella console mostrano esattamente cosa sta facendo Magical Record dietro le quinte.
Prima di poter iniziare a creare nuove note, abbiamo prima bisogno di un po 'di lavoro. Rivedi il tuo delegato dell'applicazione applicazione: didFinishLaunchingWithOptions: metodo e inizializzare un controller di navigazione con il controller della vista principale come controller della vista principale. Dai un'occhiata alla completa implementazione di applicazione: didFinishLaunchingWithOptions:.
- Applicazione (BOOL): l'applicazione (UIApplication *) ha fattoFinishLaunchingWithOptions: (NSDictionary *) launchOptions // Imposta stack dati principali [MagicalRecord setupCoreDataStack]; // Initialize View Controller self.viewController = [[MTViewController alloc] initWithNibName: @ "MTViewController" bundle: nil]; // Inizializza il controller di navigazione UINavigationController * nc = [[UINavigationController alloc] initWithRootViewController: self.viewController]; // Initialize Window self.window = [[UIWindow alloc] initWithFrame: [[UIScreen mainScreen] bound]]; [self.window setRootViewController: nc]; [self.window makeKeyAndVisible]; return YES;
Mostreremo le note in una vista tabella, quindi inizia aggiungendo una presa per una vista tabella nel file di intestazione del controller della vista principale. Selezionare il file XIB del controller della vista principale e trascinare a UITableView istanza nella vista del controller della vista. Non dimenticare di assegnare il Proprietario del file come la vista della tabella fonte di dati e delegare. Inoltre, assicurati di connettere il Proprietario del file tavolo vista presa con la vista tabella abbiamo appena aggiunto alla sua vista.
#importare@interface MTViewController: UIViewController @property (nonatomic, weak) IBOutlet UITableView * tableView; @fine
Nel file di implementazione del controller della vista principale, aggiungere una proprietà privata denominata gli appunti all'estensione della classe in alto. Assicurati che la proprietà sia di tipo NSMutableArray. Il gli appunti proprietà memorizzerà le note recuperate dall'archivio dati e fungeranno da origine dati della vista tabella.
#import "MTViewController.h" @interface MTViewController () @property (nonatomic, strong) NSMutableArray * note; @fine
Nel controller della vista viewDidLoad metodo, impostiamo la vista chiamando setupView sul controller della vista principale. Questo non è altro che un metodo di supporto per mantenere il viewDidLoad metodo conciso e sgombro. Nel setupView, aggiungiamo un pulsante modifica e aggiungi alla barra di navigazione e recuperiamo le note dall'archivio dati richiamando il fetchNotes metodo.
- (void) viewDidLoad [super viewDidLoad]; // Setup Visualizza [self setupView];
- (void) setupView // Crea pulsante Modifica UIBarButtonItem * editButton = [[UIBarButtonItem alloc]] initWithTitle: @ Stile "Modifica": UIBarButtonItemStyleBordered target: self action: @selector (editNotes :)]; self.navigationItem.leftBarButtonItem = editButton; // Crea pulsante Aggiungi UIBarButtonItem * addButton = [[UIBarButtonItem alloc] initWithTitle: @ Stile "Aggiungi": UIBarButtonItemStyleBordered target: self action: @selector (addNote :)]; self.navigationItem.rightBarButtonItem = addButton; // Recupera le note [self fetchNotes];
Potrebbe sorprendervi che il fetchNotes il metodo è solo una riga di codice. Questo è tutto grazie a Magical Record. Recuperare le note dall'archivio dati è semplice come chiamare trova tutto sul Nota classe. Il metodo restituisce una serie di record come ci si aspetterebbe. Non dimenticare di importare il file di intestazione del file Nota classe nella parte superiore del file di implementazione del controller della vista principale.
- (void) fetchNotes // Fetch Notes self.notes = [NSMutableArray arrayWithArray: [Note findAll]];
Ordinare i record è facile ed elegante. Dimentica i descrittori di ordinamento e dai un'occhiata all'implementazione aggiornata del fetchNotes metodo di seguito.
- (void) fetchNotes // Fetch Notes self.notes = [NSMutableArray arrayWithArray: [Note findAllSortedBy: @ "date" ascendente: YES]];
Il editNotes: il metodo è semplice. Tutto ciò che facciamo è cambiare lo stile di modifica della vista tabella. Questo dovrebbe essere sufficiente per ora.
- (void) editNotes: (id) sender [self.tableView setEditing:! [self.tableView isEditing] animato: YES];
Il Aggiungi nota: il metodo rimane vuoto per il momento.
- (vuoto) addNote: (id) sender
Prima di costruire ed eseguire l'applicazione, è necessario implementare i metodi richiesti del protocollo di origine dati della vista tabella. Se hai familiarità con lo sviluppo di iOS, questo non dovrebbe essere troppo difficile. Dai un'occhiata alle implementazioni dei vari metodi di seguito per chiarimenti.
- (NSInteger) tableView: (UITableView *) tableView numberOfRowsInSection: (NSInteger) section return [numero di self.notes];
- (UITableViewCell *) tableView: (UITableView *) aTableView cellForRowAtIndexPath: (NSIndexPath *) indexPath static NSString * CellIdentifier = @ "Cell"; UITableViewCell * cell = [aTableView dequeueReusableCellWithIdentifier: CellIdentifier]; if (cell == nil) cell = [[UITableViewCell alloc] initWithStyle: UITableViewCellStyleSubtitle riuseIdentifier: CellIdentifier]; // Configura cella [cella setAccessoryType: UITableViewCellAccessoryDisclosureIndicator]; // Fetch Note Note * note = [self.notes objectAtIndex: [indexPath row]]; // Configura cella [cell.textLabel setText: [nota titolo]]; [cell.detailTextLabel setText: [nota parole chiave]]; cella di ritorno;
- (BOOL) tableView: (UITableView *) tableView canEditRowAtIndexPath: (NSIndexPath *) indexPath return YES;
- (void) tableView: (UITableView *) tableView commitEditingStyle: (UITableViewCellEditingStyle) editStyle forRowAtIndexPath: (NSIndexPath *) indexPath if (editStyle == UITableViewCellEditingStyleDelete)
- (void) tableView: (UITableView *) tableView didSelectRowAtIndexPath: (NSIndexPath *) indexPath [tableView deselectRowAtIndexPath: indexPath animato: YES];
Costruisci ed esegui la tua applicazione.
Quando l'utente tocca il pulsante Aggiungi, dovrebbe apparire una vista modale che consente all'utente di aggiungere una nuova nota all'archivio dati. Crea un nuovo UIViewController sottoclasse e nominalo MTEditNoteViewController. Come indica il nome, useremo questo controller di visualizzazione per modificare le note.
Prima di passare al file XIB del controller di visualizzazione, aggiungere tre uscite al file di intestazione del controller di visualizzazione. Le prime due uscite sono istanze di UITextField per il titolo e le parole chiave della nota. La terza uscita è un'istanza di UITextView per il corpo della nota.
#importare@interface MTEditNoteViewController: UIViewController @property (nonatomic, weak) IBOutlet UITextField * titleField; @property (nonatomic, weak) IBOutlet UITextField * keywordsField; @property (nonatomic, weak) IBOutlet UITextView * bodyView; @fine
La creazione dell'interfaccia utente del controller di visualizzazione delle note di modifica non dovrebbe essere una sfida eccessiva. Aggiungi due UITextField istanze e uno UITextView istanza alla vista del controller della vista. Configura i campi di testo come desideri, ad esempio, dando loro un testo segnaposto. Non dimenticare di connettere il Proprietario del fileLe prese con i campi di testo e la visualizzazione del testo.
Dal momento che useremo il MTEditNoteViewController classe per l'aggiunta e la modifica delle note, è importante sapere quale stato (aggiunta o modifica) è attivo in qualsiasi momento. Ci sono diversi modi per risolvere questo problema. Un modo è aggiungere un privato Nota proprietà al controller della vista, che è zero se viene creata una nuova nota e che viene impostata durante l'inizializzazione quando si modifica una nota. In situazioni come questa, preferisco lavorare con inizializzatori specializzati per evitare confusione e questo è anche ciò che mi consente di mantenere il Nota proprietà privata. Oltre al privato Nota proprietà, aggiungiamo anche una seconda proprietà privata chiamata isEditing, un booleano. La ragione di ciò diventerà chiara in pochi minuti. Inoltre, non dimenticare di importare il file di intestazione del file Nota classe.
#import "MTEditNoteViewController.h" #import "Note.h" @interface MTEditNoteViewController () @property (nonatomic, strong) Nota * nota; @property (nonatomic, assign) BOOL isEditing; @fine
Passiamo attraverso i vari metodi passo dopo passo. Innanzitutto, vogliamo essere certi di poter aggiungere nuove note all'archivio dati senza problemi. Iniziamo con il initWithnibName: bundle: metodo. L'unico cambiamento che facciamo è impostare il isEditing proprietà a NO.
- (id) initWithNibName: (NSString *) nibNameOrNil bundle: (NSBundle *) nibBundleOrNil self = [super initWithNibName: nibNameOrNil bundle: nibBundleOrNil]; if (self) // Set Flag self.isEditing = NO; return self;
Come abbiamo visto in precedenza, nel viewDidLoad metodo, impostiamo la vista invocando a setupView metodo in cui creiamo i pulsanti Annulla e Salva. Si noti che creiamo il pulsante Annulla solo se il Nota la proprietà è uguale a zero. La ragione è che presentiamo il controller della vista in modo modale quando aggiungiamo nuove note, ma noi spingiamo il controller della vista su uno stack di navigazione quando modifichiamo una nota. Se la Nota la proprietà non è uguale a zero, compiliamo anche i campi di testo e la vista del testo con i contenuti del Nota proprietà.
- (void) viewDidLoad [super viewDidLoad]; // Setup Visualizza [self setupView];
- (void) setupView // Crea pulsante Annulla if (! self.note) UIBarButtonItem * cancelButton = [[UIBarButtonItem alloc]] initWithTitle: @ Stile "Annulla": UIBarButtonItemStyleBordered target: self action: @selector (cancel :)]; self.navigationItem.leftBarButtonItem = cancelButton; // Crea pulsante di salvataggio UIBarButtonItem * saveButton = [[UIBarButtonItem alloc] initWithTitle: @ Stile "Salva": UIBarButtonItemStyleBordered target: self action: @selector (salva :)]; self.navigationItem.rightBarButtonItem = saveButton; if (self.note) // Popola campi modulo [self.titleField setText: [self.note title]]; [self.keywordsField setText: [self.note keywords]]; [self.bodyView setText: [self.note body]];
Il Annulla: il metodo non dovrebbe riservare sorprese.
- (void) cancel: (id) sender // Ignora controller vista [self dismissViewControllerAnimated: YES completion: nil];
Il salvare: il metodo è un po 'più prolisso, ma non dovrebbe essere troppo difficile. Per prima cosa controlliamo se il controller della vista Nota la proprietà è impostata. Se è impostato, sappiamo che una nota è stata modificata, non creata. Se la Nota la proprietà è uguale a zero allora sappiamo che dovrebbe essere creata una nuova nota. L'eliminazione del controller della vista è un po 'complicata dal momento che è necessario chiudere il controller della vista se è presentato in modo modale quando è stata creata una nota e spostarla dallo stack di navigazione quando è stata modificata una nota. Questa è la ragione per cui abbiamo creato il isEditing proprietà.
- (void) save: (id) sender if (! self.note) // Crea nota self.note = [Nota createEntity]; // Configura nota [self.note setDate: [Data NSDate]]; // Configura nota [self.note setTitle: [self.titleField text]]; [self.note setKeywords: [self.keywordsField text]]; [self.note setBody: [self.bodyView text]]; // Salva contesto oggetto gestito [[NSManagedObjectContext defaultContext] saveNestedContexts]; if (self.isEditing) // Pop View Controller da Stack di navigazione [self.navigationController popViewControllerAnimated: YES]; else // Ignora controller di visualizzazione [self dismissViewControllerAnimated: YES completion: nil];
Come puoi vedere, la creazione di una nuova nota è un'altra one-liner quando usi Magical Record. Compiliamo la nota con il contenuto dei campi del modulo e salviamo il contesto dell'oggetto gestito della nota. Recuperare un riferimento al contesto dell'oggetto gestito è facile con Magical Record. Tutto quello che dobbiamo fare è chiedere il NSManagedObjectContext classe per il contesto predefinito. Salvare il contesto è identico al salvataggio di un contesto senza Magical Record. Anche se registriamo l'errore se qualcosa va storto, questo non è realmente necessario dal momento che Magical Record registra per noi eventuali errori nella console.
È giunto il momento di modificare il Aggiungi nota: metodo nel controller della vista principale. Non dimenticare di importare il file di intestazione del file MTEditNoteViewController classe.
- (void) addNote: (id) sender // Inizializza Modifica nota Visualizza controller MTEditNoteViewController * vc = [[MTEditNoteViewController alloc] initWithNibName: @ "MTEditNoteViewController" bundle: [NSBundle mainBundle]]; // Inizializza il controller di navigazione UINavigationController * nc = [[UINavigationController alloc] initWithRootViewController: vc]; // Present View Controller [self.navigationController presentViewController: nc animated: YES completion: nil];
Ogni volta che una nuova nota viene aggiunta all'archivio dati, dovremmo aggiornare la vista tabella per visualizzare le modifiche. Per un'applicazione di produzione, un approccio migliore sarebbe osservare le modifiche nel contesto dell'oggetto gestito. Tuttavia, in questa applicazione di esempio, recuperiamo le note dall'archivio dati e ricarichiamo la vista tabella ogni volta che appare la vista principale (ri). Questo è costoso e quindi non consigliato se si prevede di inviare la propria applicazione all'App Store. Per situazioni come questa, un controller risultati recuperato è una soluzione perfetta.
- (vuoto) viewWillAppear: (BOOL) animato [super viewWillAppear: animated]; // Recupera le note [self fetchNotes]; // Reload Table View [self.tableView reloadData];
L'aggiornamento delle note è quasi facile come aggiungere note. Come accennato in precedenza, creeremo un inizializzatore specializzato per impostare il controller della vista Nota proprietà. Aggiorna il file di intestazione del file MTEditNoteViewController classe aggiungendo il nuovo inizializzatore come mostrato di seguito. Non dimenticare di aggiungere anche una dichiarazione di classe per il Nota classe al file di intestazione.
#importare@class Nota; @interface MTEditNoteViewController: UIViewController @property (nonatomic, weak) IBOutlet UITextField * titleField; @property (nonatomic, weak) IBOutlet UITextField * keywordsField; @property (nonatomic, weak) IBOutlet UITextView * bodyView; - (id) initWithNote: (Nota *) nota; @fine
L'inizializzatore specializzato non è davvero speciale. Tutto ciò che facciamo è impostare il controller della vista Nota e isEditing proprietà come puoi vedere qui sotto.
- (id) initWithNote: (Nota *) note self = [auto initWithNibName: @ "MTEditNoteViewController": [NSBundle mainBundle]]; if (self) // Imposta nota self.note = note; // Imposta Flag self.isEditing = YES; return self;
Prima di creare ed eseguire l'applicazione ancora una volta, è necessario aggiornare il controller della vista principale tableView: didSelectRowAtIndexPath: metodo. In questo metodo, recuperiamo la nota corretta, inizializziamo un'istanza di MTEditNoteViewController classe e spingere il controller della vista sullo stack di navigazione.
- (void) tableView: (UITableView *) tableView didSelectRowAtIndexPath: (NSIndexPath *) indexPath [tableView deselectRowAtIndexPath: indexPath animato: YES]; // Fetch Note Note * note = [self.notes objectAtIndex: [indexPath row]]; // Inizializza Modifica Nota Visualizza controller MTEditNoteViewController * vc = [[MTEditNoteViewController alloc] initWithNote: note]; // Spingi il controller di visualizzazione sullo stack di navigazione [self.navigationController pushViewController: vc animated: YES];
Per cancellare la nota, dobbiamo modificare il tableView: commitEditingStyle: forRowAtIndexPath: metodo. Prendiamo la nota, la cancelliamo dall'origine dati e il contesto dell'oggetto gestito, e aggiorniamo la vista tabella. Come puoi vedere, l'eliminazione di un record o entità dall'archivio dati è semplice come l'invio di un messaggio di DeleteEntity.
- (void) tableView: (UITableView *) tableView commitEditingStyle: (UITableViewCellEditingStyle) editStyle forRowAtIndexPath: (NSIndexPath *) indexPath if (editStyle == UITableViewCellEditingStyleDelete) // Fetch Note Note * note = [self.notes objectAtIndex: [indexPath row] ]; // Elimina nota dall'origine dati [self.notes removeObjectAtIndex: [indexPath row]]; // Delete Entity [note deleteEntity]; // Aggiorna tabella Visualizza [tableView deleteRowsAtIndexPaths: [NSArray arrayWithObject: indexPath] withRowAnimation: UITableViewRowAnimationFade];
Costruendo Magical Record, abbiamo solo scalfito la superficie. Voglio sottolineare che Magical Record è una biblioteca robusta e matura e non solo una fusione di una manciata di categorie utili. Come ti ho mostrato, Magical Record rende il lavoro con Core Data molto più semplice e meno prolisso. Le attività comuni sono spesso one-liner. Confronta i seguenti frammenti di codice per recuperare tutte le note e ordinarle per data. Utilizzando Core Data, ciò comporterebbe il seguente frammento di codice.
NSFetchRequest * fr = [[NSFetchRequest alloc] init]; NSEntityDescription * ed = [NSEntityDescription entityForName: @ "Note" inManagedObjectContext: [NSManagedObjectContext defaultContext]]; [fr setEntity: ed]; NSSortDescriptor * sd = [NSSortDescriptor sortDescriptorWithKey: @ "data" crescente: SÌ]; [fr setSortDescriptors: @ [sd]]; NSError * error = nil; NSArray * result = [[NSManagedObjectContext defaultContext] executeFetchRequest: fr error: & error];
Usando Magical Record, tuttavia, questo richiede solo una riga di codice.
NSArray * result = [Nota findAllSortedBy: @ "date" crescente: YES];
Se dovessimo aggiungere la possibilità di cercare l'elenco di note, un approccio - sebbene non ideale - sarebbe quello di cercare nell'archivio dati tutte le note con un titolo o una parola chiave che conteneva la query. Usando Magical Record ciò comporterebbe la seguente implementazione.
NSPredicate * predicate1 = [NSPredicate predicateWithFormat: @ "title contains [cd]% @", query]; NSPredicate * predicate2 = [predicato NSPredicateWithFormat: @ "keywords contiene [cd]% @", query]; NSPredicate * predicate = [NSCompoundPredicate orPredicateWithSubpredicates: @ [predicate1, predicate2]]; NSArray * result = [Note findAllWithPredicate: predicate];
Come ho già detto, Magical Record ha molto altro da offrire rispetto a quello che ti ho mostrato in questo tutorial. Dalla versione 2.0, Magical Record può gestire contesti nidificati e fornisce anche supporto per iCloud e operazioni con thread. L'obiettivo principale di questo tutorial è mostrarti che i Core Data non devono essere ingombranti e Saul Mora lo illustra con Magical Record.
Accentsconagua