Guida introduttiva a Core Data Tutorial

Questo è un capitolo abbreviato dal nostro libro Core Data by Tutorials, che è stato completamente aggiornato per Swift 4.2 e iOS 12. Questo tutorial è presentato come parte del nostro iOS 12 Launch Party-buon divertimento!

Benvenuti a Core Data!

In questo tutorial, scriverai la tua prima app Core Data. Vedrai quanto è facile iniziare con tutte le risorse fornite in Xcode, dai modelli di codice iniziale all’editor del modello di dati.

Si sta andando a colpire il terreno in esecuzione fin dall’inizio. Alla fine del tutorial saprai come:

• Dati del modello utilizzando l’editor di modelli di Xcode
• Aggiungi nuovi record a Core Data
• Recupera un set di record da Core Data
• Visualizza i record recuperati utilizzando una vista tabella.

Avrai anche un’idea di cosa sta facendo Core Data dietro le quinte e di come puoi interagire con i vari pezzi in movimento.

Guida introduttiva

Apri Xcode e crea un nuovo progetto iOS basato sul modello di app Vista singola. Assegna un nome alla HitList dell’app e assicurati che Use Core Data sia selezionato.

Selezionando la casella Usa dati core, Xcode genererà codice boilerplate per ciò che è noto come NSPersistentContainer in AppDelegate.Swift.

NSPersistentContainer è costituito da un insieme di oggetti che facilitano il salvataggio e il recupero delle informazioni dai dati principali. All’interno di questo contenitore è un oggetto per gestire lo stato dei dati di base nel suo complesso, un oggetto che rappresenta il modello di dati, e così via.

Lo stack standard funziona bene per la maggior parte delle app, ma a seconda della tua app e dei suoi requisiti di dati, puoi personalizzare lo stack per essere più efficiente.

L’idea per questa applicazione di esempio è semplice: Ci sarà una vista tabella con un elenco di nomi per il vostro molto proprio “hit list”. Sarete in grado di aggiungere nomi a questo elenco e, infine, utilizzare i dati di base per assicurarsi che i dati siano memorizzati tra le sessioni. Noi non condoniamo la violenza su questo sito, in modo da poter pensare a questa applicazione come un elenco di preferiti per tenere traccia dei tuoi amici troppo, naturalmente!

Clicca su Principale.storyboard per aprirlo in Interface Builder. Selezionare il controller di visualizzazione sulla tela e incorporarlo all’interno di un controller di navigazione. Dal menu Editor di Xcode, selezionare Incorpora in Controller ▸ Controller di navigazione.

Fare clic sulla barra di navigazione del controller di navigazione per selezionarlo, quindi fare clic su Preferisce titoli di grandi dimensioni nell’Ispettore attributi. Ciò darà all’app di esempio uno stile di titolo che corrisponde alle app stock di Apple.

Quindi, trascinare una vista tabella dalla libreria oggetti nel controller di visualizzazione, quindi ridimensionarla in modo che copra l’intera vista.

Se non è già aperto, utilizzare l’icona situata nell’angolo in basso a sinistra dell’area di disegno per aprire la struttura del documento di Interface Builder.

Ctrl-trascina dalla vista Tabella nella struttura del documento alla vista padre e seleziona il vincolo Spazio all’area sicura:

Fai questo altre tre volte, selezionando i vincoli che trascinano lo spazio nell’area sicura, lo spazio superiore nell’area sicura e infine lo spazio inferiore nell’area sicura. L’aggiunta di questi quattro vincoli farà sì che la vista tabella riempia la sua vista padre.

Quindi, trascinare un elemento del pulsante Bar e posizionarlo sulla barra di navigazione del controller di visualizzazione. Infine, selezionare la voce pulsante bar e cambiare la sua voce di sistema per aggiungere.

La tua tela dovrebbe essere simile alla seguente schermata:

Ogni volta che si tocca il pulsante Aggiungi, verrà visualizzato un controller di avviso contenente un campo di testo. Da lì, sarete in grado di digitare il nome di qualcuno nel campo di testo. Toccando Save si salva il nome, si chiude il controller di avviso e si aggiorna la vista tabella, visualizzando tutti i nomi immessi.

Ma prima, è necessario rendere il controller di visualizzazione l’origine dati della vista tabella. Nell’area di disegno, Ctrl-trascina dalla vista tabella all’icona del controller di visualizzazione gialla sopra la barra di navigazione, come mostrato di seguito, e fai clic su dataSource:

Nel caso ve lo stiate chiedendo, non è necessario impostare il delegato della vista tabella poiché toccare le celle non attiverà alcuna azione. Non diventa più semplice di questo!

Aprire l’editor assistente premendo Command-Option-Enter o selezionando il pulsante centrale sul set di strumenti Editor sulla barra Xcode.

Ctrl-trascina dalla vista tabella su ViewController.swift all’interno della definizione della classe per creare un IBOutlet.

Quindi, denominare la nuova proprietà IBOutlet tableView, risultando nella seguente riga:

@IBOutlet weak var tableView: UITableView!

Quindi, Ctrl-trascina dal pulsante Aggiungi in ViewController.swift appena sotto la tua definizione viewDidLoad(). Questa volta, crea un’azione invece di una presa, nominando il metodo addName, con un tipo UIBarButtonItem:

@IBAction func addName(_ sender: UIBarButtonItem) { }

Ora puoi fare riferimento alla vista tabella e all’azione dell’elemento del pulsante bar nel codice.

Successivamente, verrà impostato il modello per la vista tabella. Aggiungere la seguente proprietà a ViewController.swift sotto il tableView IBOutlet:

var names: = 

names è un array mutabile che contiene valori di stringa visualizzati dalla vista tabella. Quindi, sostituire l’implementazione di viewDidLoad() con quanto segue:

override func viewDidLoad() { super.viewDidLoad() title = "The List" tableView.register(UITableViewCell.self, forCellReuseIdentifier: "Cell")}

Questo imposterà un titolo sulla barra di navigazione e registrerà la classe UITableViewCell con la vista tabella.

Avanti, ancora in ViewController.swift, aggiungi la seguente estensione UITableViewDataSource sotto la definizione della classe per ViewController:

// MARK: - UITableViewDataSourceextension ViewController: UITableViewDataSource { func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return names.count } func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) cell.textLabel?.text = names return cell }}

Se hai mai lavorato con UITableView, questo codice dovrebbe sembrare molto familiare. Per prima cosa restituisci il numero di righe nella tabella come numero di elementi nell’array names.

Successivamente, tableView(_:cellForRowAt:) elimina le celle della vista tabella e le popola con la stringa corrispondente dall’array names.

Successivamente, è necessario un modo per aggiungere nuovi nomi in modo che la vista tabella possa visualizzarli. Implementa il metodo addName IBAction che hai trascinato Ctrl nel tuo codice in precedenza:

// Implement the addName IBAction@IBAction func addName(_ sender: UIBarButtonItem) { let alert = UIAlertController(title: "New Name", message: "Add a new name", preferredStyle: .alert) let saveAction = UIAlertAction(title: "Save", style: .default) { action in guard let textField = alert.textFields?.first, let nameToSave = textField.text else { return } self.names.append(nameToSave) self.tableView.reloadData() } let cancelAction = UIAlertAction(title: "Cancel", style: .cancel) alert.addTextField() alert.addAction(saveAction) alert.addAction(cancelAction) present(alert, animated: true)}

Ogni volta che si tocca il pulsante Aggiungi, questo metodo presenterà un UIAlertController con un campo di testo e due pulsanti: Salva e Annulla.

Save inserisce il testo corrente dei campi di testo nell’array names quindi ricarica la vista tabella. Poiché l’array names è il modello che supporta la vista tabella, qualsiasi cosa tu digiti nel campo di testo apparirà nella vista tabella.

Infine, crea ed esegui la tua app per la prima volta. Quindi, tocca il pulsante Aggiungi. Il controller di avviso sarà simile a questo:

Aggiungere quattro o cinque nomi alla lista. Si dovrebbe vedere qualcosa di simile al di sotto:

La tua vista tabella visualizzerà i dati e il tuo array memorizzerà i nomi, ma la grande cosa che manca qui è la persistenza. L’array è in memoria, ma se si forza chiudere l’applicazione o riavviare il dispositivo, l’elenco dei risultati verrà spazzato via. Core Data fornisce persistenza, il che significa che può memorizzare i dati in uno stato più duraturo in modo che possa sopravvivere a un riavvio dell’app o al riavvio del dispositivo.

Non hai ancora aggiunto alcun elemento di dati di base, quindi nulla dovrebbe persistere dopo esserti allontanato dall’app. Proviamo. Premere il tasto Home se si sta utilizzando un dispositivo fisico o l’equivalente (Shift + H + H) se si sta utilizzando il Simulatore. Questo vi porterà di nuovo alla griglia app familiare nella schermata iniziale:

Dalla schermata iniziale, tocca l’icona HitList per riportare l’app in primo piano. I nomi sono ancora sullo schermo. Che cos’è successo?

Quando si tocca il pulsante Home, l’app attualmente in primo piano passa allo sfondo. Quando ciò accade, il sistema operativo blocca tutto ciò che è attualmente in memoria, comprese le stringhe nell’array dei nomi. Allo stesso modo, quando è il momento di svegliarsi e tornare in primo piano, il sistema operativo ripristina quello che era in memoria come se non avessi mai lasciato.

Apple ha introdotto questi progressi nel multitasking in iOS 4. Creano un’esperienza senza soluzione di continuità per gli utenti iOS, ma aggiungono una ruga alla definizione di persistenza per gli sviluppatori iOS. I nomi sono davvero persistiti?

No, non proprio. Se tu avessi completamente ucciso l’applicazione nel fast app switcher o spento il telefono, quei nomi sarebbero andati. Puoi verificare anche questo. Con l’app in primo piano, inserisci lo switcher di app veloce. Puoi farlo toccando due volte il pulsante Home se il tuo dispositivo ne ha uno o trascinandolo lentamente verso l’alto dalla parte inferiore dello schermo se sei su un iPhone X.

Da qui, scorri l’istantanea dell’app HitList verso l’alto per terminare l’app. Se stai lavorando su un iPhone X, devi premere a lungo l’istantanea dell’app fino a quando non viene visualizzato un pulsante rosso Elimina in alto a destra.

Dopo aver rimosso l’app dall’app switcher, non dovrebbe esserci traccia di HitList nella memoria vivente (nessun gioco di parole). Verificare i nomi sono andati tornando alla schermata iniziale e toccando l’icona HitList per attivare un nuovo lancio.

La differenza tra il congelamento del flash e la persistenza potrebbe essere ovvia se hai lavorato con iOS per qualche tempo e hai familiarità con il modo in cui funziona il multitasking. Nella mente di un utente, tuttavia, non c’è differenza. All’utente non importa perché i nomi sono ancora lì, se l’app è passata in secondo piano ed è tornata, o perché l’app li ha salvati e ricaricati. Tutto ciò che conta è che i nomi sono ancora lì quando l’applicazione torna!

Quindi il vero test di persistenza è se i tuoi dati sono ancora lì dopo un nuovo avvio dell’app.

Modellazione dei dati

Ora sai come verificare la persistenza, puoi immergerti nei dati principali. Il tuo obiettivo per l’app HitList è semplice: mantieni i nomi immessi in modo che siano disponibili per la visualizzazione dopo un nuovo avvio dell’app.

Fino a questo punto, hai usato semplici vecchie stringhe Swift per memorizzare i nomi in memoria. In questa sezione, sostituirai queste stringhe con oggetti Dati principali.

Il primo passo è creare un modello a oggetti gestito, che descrive il modo in cui Core Data rappresenta i dati sul disco.

Per impostazione predefinita, Core Data utilizza un database SQLite come archivio persistente, quindi puoi pensare al modello di dati come allo schema del database.

Poiché hai scelto di utilizzare Core Data, Xcode ha creato automaticamente un file di modello di dati per te e lo ha chiamato HitList.xcdatamodeld.

Apri HitList.xcdatamodeld. Come puoi vedere, Xcode ha un potente editor di modelli di dati:

L’editor del modello di dati ha molte funzionalità che puoi esplorare in seguito. Per ora, concentriamoci sulla creazione di una singola entità di dati Core.

Fare clic su Aggiungi entità in basso a sinistra per creare una nuova entità. Fare doppio clic sulla nuova entità e cambiarne il nome in Persona, in questo modo:

Potresti chiederti perché l’editor del modello usa il termine Entity. Non stavi semplicemente definendo una nuova classe? Come vedrete a breve, Core Data viene fornito con il proprio vocabolario. Ecco una rapida carrellata di alcuni termini che incontrerai comunemente:

• Un’entità è una definizione di classe nei dati principali. L’esempio classico è un Employee o un Company. In un database relazionale, un’entità corrisponde a una tabella.
• Un attributo è un’informazione associata a una particolare entità. Ad esempio, un’entità Employee potrebbe avere attributi per name, position e salarydel dipendente. In un database, un attributo corrisponde a un particolare campo in una tabella.
• Una relazione è un collegamento tra più entità. Nei dati di base, le relazioni tra due entità sono chiamate relazioni a-uno, mentre quelle tra una e molte entità sono chiamate relazioni a-molti. Ad esempio, un Manager può avere una relazione a molti con un insieme di dipendenti, mentre un individuo Employee di solito ha una relazione a uno con il suo manager.

Ora sai cos’è un attributo, puoi aggiungere un attributo all’oggetto Person creato in precedenza. Ancora in HitList.xcdatamodeld, selezionare Person sul lato sinistro e fare clic sul segno più ( + ) sotto Attributi.

Imposta il nome del nuovo attributo su, er, name e cambia il suo tipo in String:

Nei dati principali, un attributo può essere di uno dei diversi tipi di dati.

Salvataggio in dati core

Apri ViewController.swift, aggiungere il seguente modulo di dati di base di importazione sotto il UIKit importazione:

import CoreData

Questa importazione è tutto ciò di cui hai bisogno per iniziare a utilizzare l’API dei dati principali nel tuo codice.

Quindi, sostituire la definizione della proprietà names con la seguente:

var people: = 

Memorizzerai le entità Person piuttosto che i nomi delle stringhe, quindi rinominerai l’array che funge da modello di dati della vista tabella in people. Ora contiene istanze di NSManagedObject piuttosto che semplici stringhe.

NSManagedObject rappresenta un singolo oggetto memorizzato in Core Data; è necessario utilizzarlo per creare, modificare, salvare ed eliminare dal proprio Core Data persistent store. Come vedrai a breve, NSManagedObject è un mutaforma. Può assumere la forma di qualsiasi entità nel modello di dati, appropriandosi di qualsiasi attributo e relazione definita.

Poiché si sta modificando il modello della vista tabella, è necessario sostituire entrambi i metodi di origine dati implementati in precedenza. Sostituisci l’estensione UITableViewDataSource con la seguente:

// MARK: - UITableViewDataSourceextension ViewController: UITableViewDataSource { func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return people.count } func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let person = people let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) cell.textLabel?.text = person.value(forKeyPath: "name") as? String return cell }}

Il cambiamento più significativo a questi metodi si verifica in tableView(_:cellForRowAt:). Invece di abbinare le celle con la stringa corrispondente nell’array del modello, ora si associano le celle con il corrispondente NSManagedObject.

Nota come prendi l’attributo name da NSManagedObject. Succede qui:

cell.textLabel?.text = person.value(forKeyPath: "name") as? String

Perche ‘ devi farlo? A quanto pare, NSManagedObject non conosce l’attributo name che hai definito nel tuo modello di dati, quindi non c’è modo di accedervi direttamente con una proprietà. L’unico modo in cui Core Data fornisce per leggere il valore è la codifica chiave-valore, comunemente indicata come KVC.

Quindi, trova addName(_:) e sostituisci save UIAlertAction con quanto segue:

let saveAction = UIAlertAction(title: "Save", style: .default) { action in guard let textField = alert.textFields?.first, let nameToSave = textField.text else { return } self.save(name: nameToSave) self.tableView.reloadData()}

Questo prende il testo nel campo di testo e lo passa a un nuovo metodo chiamato save(name:). Xcode si lamenta perché save(name:) non esiste ancora. Aggiungilo qui sotto addName(_:):

func save(name: String) { guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return } // 1 let managedContext = appDelegate.persistentContainer.viewContext // 2 let entity = NSEntityDescription.entity(forEntityName: "Person", in: managedContext)! let person = NSManagedObject(entity: entity, insertInto: managedContext) // 3 person.setValue(name, forKeyPath: "name") // 4 do { try managedContext.save() people.append(person) } catch let error as NSError { print("Could not save. \(error), \(error.userInfo)") }}

Questo è dove i dati di base calci in! Ecco cosa fa il codice:

1. Prima di poter salvare o recuperare qualsiasi cosa dal tuo archivio dati principale, devi prima mettere le mani su un NSManagedObjectContext. È possibile considerare un contesto oggetto gestito come un “scratchpad” in memoria per lavorare con gli oggetti gestiti.

   Pensa di salvare un nuovo oggetto gestito in Core Data come un processo in due fasi: in primo luogo, inserisci un nuovo oggetto gestito in un contesto di oggetto gestito; una volta che sei felice, “commetti” le modifiche nel tuo contesto di oggetto gestito per salvarlo su disco.

   Xcode ha già generato un contesto oggetto gestito come parte del modello del nuovo progetto. Ricorda, questo accade solo se si seleziona la casella di controllo Usa dati core all’inizio. Questo contesto di oggetto gestito predefinito vive come una proprietà di NSPersistentContainer nel delegato dell’applicazione. Per accedervi, si ottiene prima un riferimento al delegato app.

2. Si crea un nuovo oggetto gestito e lo si inserisce nel contesto dell’oggetto gestito. Puoi farlo in un solo passaggio con il metodo statico di NSManagedObject: entity(forEntityName:in:).

   Ci si potrebbe chiedere che cosa un NSEntityDescription è tutto. Ricordiamo in precedenza, NSManagedObject è stato chiamato una classe shape-shifter perché può rappresentare qualsiasi entità. Una descrizione di entità è il pezzo che collega la definizione di entità dal modello di dati con un’istanza di NSManagedObject in fase di runtime.

1. Con un NSManagedObject in mano, si imposta l’attributo name utilizzando la codifica chiave-valore. Devi scrivere la chiave KVC (name in questo caso) esattamente come appare nel tuo modello di dati, altrimenti la tua app si bloccherà in fase di runtime.
2. Si commettono le modifiche a person e si salvano su disco chiamando save nel contesto dell’oggetto gestito. Nota save può generare un errore, motivo per cui lo si chiama utilizzando la parola chiave try all’interno di un blocco do-catch. Infine, inserisci il nuovo oggetto gestito nell’array people in modo che venga visualizzato quando la vista tabella viene ricaricata.

È un po ‘ più complicato dell’utilizzo di una serie di stringhe, ma non troppo male. Parte del codice qui, come ottenere il contesto e l’entità dell’oggetto gestito, potrebbe essere eseguito solo una volta nel proprio init() o viewDidLoad() quindi riutilizzato in seguito. Per semplicità, stai facendo tutto nello stesso metodo.

Crea ed esegui l’app e aggiungi alcuni nomi alla vista tabella:

Se i nomi sono effettivamente memorizzati in Core Data, l’app HitList dovrebbe superare il test di persistenza. Con l’app in primo piano, vai allo switcher di app veloce e poi terminalo.

Da Springboard, tocca l’app HitList per attivare un nuovo lancio. Aspetta, cos’e ‘ successo? La vista tabella è vuota:

Hai salvato in Core Data, ma dopo un nuovo avvio dell’app, l’array people è vuoto! Questo perché i dati sono seduti sul disco in attesa di te, ma non lo stai ancora mostrando.

Recupero da Core Data

Per ottenere i dati dal tuo archivio persistente nel contesto dell’oggetto gestito, devi recuperarlo. Apri ViewController.swift e aggiungere quanto segue viewDidLoad():

override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated) //1 guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return } let managedContext = appDelegate.persistentContainer.viewContext //2 let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person") //3 do { people = try managedContext.fetch(fetchRequest) } catch let error as NSError { print("Could not fetch. \(error), \(error.userInfo)") }}

Passo dopo passo, questo è ciò che fa il codice:

1. Prima di poter fare qualsiasi cosa con i dati di base, è necessario un contesto oggetto gestito. Il recupero non è diverso! Come prima, si tira su il delegato dell’applicazione e si afferra un riferimento al suo contenitore persistente per mettere le mani sul suo NSManagedObjectContext.
2. Come suggerisce il nome, NSFetchRequest è la classe responsabile del recupero dai dati principali. Le richieste di recupero sono sia potenti che flessibili. È possibile utilizzare le richieste di recupero per recuperare un insieme di oggetti che soddisfano i criteri forniti (ad es. dammi tutti i dipendenti che vivono in Wisconsin e sono stati con l’azienda almeno tre anni), valori individuali (cioè dammi il nome più lungo nel database) e altro ancora.

   Le richieste di recupero hanno diversi qualificatori utilizzati per perfezionare l’insieme di risultati restituiti. Per ora, dovresti sapere che NSEntityDescription è uno di questi qualificatori richiesti.

   Impostando la proprietà entity di una richiesta di recupero, o in alternativa inizializzandola con init(entityName:), recupera tutti gli oggetti di una particolare entità. Questo è quello che fai qui per recuperare tutte le entità Person. Si noti inoltre che NSFetchRequest è un tipo generico. Questo uso di generici specifica il tipo di ritorno previsto di una richiesta di recupero, in questo caso NSManagedObject.

3. Si consegna la richiesta di recupero al contesto dell’oggetto gestito per eseguire il sollevamento pesante. fetch(_:) restituisce un array di oggetti gestiti che soddisfano i criteri specificati dalla richiesta di recupero.

Crea ed esegui l’applicazione. Immediatamente, dovresti vedere l’elenco dei nomi che hai aggiunto in precedenza:

Fantastico! Sono tornati dai morti (gioco di parole). Aggiungere un paio di nomi alla lista e riavviare l’applicazione per verificare il salvataggio e il recupero stanno funzionando. A parte l’eliminazione dell’app, il ripristino del simulatore o il lancio del telefono da un edificio alto, i nomi appariranno nella vista tabella indipendentemente da cosa.

Punti chiave

• Core Data fornisce persistenza su disco, il che significa che i dati saranno accessibili anche dopo aver terminato l’app o spento il dispositivo. Questo è diverso dalla persistenza in memoria, che salverà i tuoi dati solo finché la tua app è in memoria, in primo piano o in background.
• Xcode è dotato di un potente editor di modelli di dati, che è possibile utilizzare per creare il modello a oggetti gestito.
• Un modello a oggetti gestito è costituito da entità, attributi e relazioni
• Un’entità è una definizione di classe nei dati principali.
• Un attributo è un’informazione associata a un’entità.
• Una relazione è un collegamento tra più entità.
• Un NSManagedObject è una rappresentazione in runtime di un’entità di dati di base. È possibile leggere e scrivere i suoi attributi utilizzando la codifica chiave-valore.
• È necessario un NSManagedObjectContext a save() o fetch(_:) dati da e verso i dati principali.

Dove andare da qui?

È possibile scaricare il progetto completato per questo tutorial utilizzando i pulsanti “Scarica materiali” nella parte superiore o inferiore di questo tutorial.

In questo tutorial, hai già sperimentato diversi concetti fondamentali di dati fondamentali: modelli di dati, entità, attributi, oggetti gestiti, contesti di oggetti gestiti e richieste di recupero.

Se ti è piaciuto quello che hai imparato in questo tutorial, perché non controllare i dati di base completi dal libro Tutorial, disponibile nel nostro negozio?

Ecco un assaggio di ciò che è nel libro:

1. Capitolo 1, la tua prima app Core Data: fai clic su File ▸ Nuovo progetto e scrivi un’app Core Data da zero! Questo capitolo illustra le basi per impostare il modello di dati e quindi aggiungere e recuperare record.

2. Capitolo 2, Sottoclassi NSManagedObject: NSManagedObject è la classe di archiviazione dei dati di base dei grafici degli oggetti dati di base. Questo capitolo ti insegnerà come personalizzare le sottoclassi degli oggetti gestiti per archiviare e convalidare i dati.

3. Capitolo 3, lo stack di dati di base: sotto il cofano, i dati di base sono costituiti da molte parti che lavorano insieme. In questo capitolo, imparerai come queste parti si incastrano e ti allontanerai dal modello Xcode starter per creare il tuo sistema personalizzabile.

4. Capitolo 4, Recupero intermedio: le tue app recupereranno i dati tutto il tempo e Core Data offre molte opzioni per ottenere i dati in modo efficiente. Questo capitolo copre richieste di recupero più avanzate, predicati, ordinamento e recupero asincrono.

5. Capitolo 5, NSFetchedResultsController: le viste tabella sono al centro di molte app iOS e Apple vuole far giocare bene i dati di base con loro! In questo capitolo, imparerai come NSFetchedResultsController può risparmiare tempo e codice quando le viste della tabella sono supportate dai dati dei dati principali.

6. Capitolo 6, Versioning e migrazione: mentre aggiorni e migliori la tua app, il suo modello di dati dovrà quasi certamente cambiare. In questo capitolo, imparerai come creare più versioni del modello di dati e quindi migrare gli utenti in avanti in modo che possano mantenere i dati esistenti durante l’aggiornamento.

7. Capitolo 7, Test unitari: il test è una parte importante del processo di sviluppo e non dovresti lasciare i dati principali fuori da questo! In questo capitolo, imparerai come impostare un ambiente di test separato per i dati principali e vedi esempi su come testare i tuoi modelli.

8. Capitolo 8, misurazione e miglioramento delle prestazioni: Nessuno si è mai lamentato del fatto che un’app fosse troppo veloce, quindi è importante essere vigili sul monitoraggio delle prestazioni. In questo capitolo, imparerai come misurare le prestazioni della tua app con vari strumenti Xcode e poi raccogli alcuni suggerimenti per gestire i punti lenti nel tuo codice.

9. Capitolo 9, Più contesti oggetto gestiti: In questo capitolo finale, si espanderà il solito stack di dati di base per includere più contesti oggetto gestiti. Imparerai come questo può migliorare le prestazioni percepite e contribuire a rendere l’architettura dell’app meno monolitica e più compartimentalizzata.

E per contribuire ad addolcire l’affare, l’edizione digitale del libro è in vendita per $44.99! Ma non aspettare-questo prezzo di vendita è disponibile solo per un tempo limitato.

Parlando di offerte dolci, assicuratevi di controllare i grandi premi che stiamo dando via quest’anno con il partito di lancio di iOS 11, tra cui oltre $9,000 in omaggi!

Per poter beneficiare di questo epico giveaway iOS 12, tutto ciò che devi fare è lasciare un commento sul post di lancio originale, facendoci sapere quale libro o corso è il tuo preferito in questa lista — o quale libro o corso imminente sei più entusiasta!

Ci auguriamo che questo aggiornamento, e rimanete sintonizzati per ulteriori versioni di libri e aggiornamenti!