Mise en route avec le tutoriel Core Data

Il s’agit d’un chapitre abrégé de notre livre Core Data by Tutorials, qui a été entièrement mis à jour pour Swift 4.2 et iOS 12. Ce tutoriel est présenté dans le cadre de notre soirée de lancement iOS 12 – profitez-en!

Bienvenue sur Core Data!

Dans ce tutoriel, vous allez écrire votre toute première application Core Data. Vous verrez à quel point il est facile de démarrer avec toutes les ressources fournies dans Xcode, des modèles de code de démarrage à l’éditeur de modèle de données.

Vous allez frapper le sol dès le début. À la fin du tutoriel, vous saurez comment:

• Données de modèle à l’aide de l’éditeur de modèle de Xcode
• Ajouter de nouveaux enregistrements aux données de base
• Récupérer un ensemble d’enregistrements à partir des données de base
• Afficher les enregistrements récupérés à l’aide d’une vue de table.

Vous aurez également une idée de ce que Core Data fait en coulisses et de la manière dont vous pouvez interagir avec les différentes pièces en mouvement.

Mise en route

Ouvrez Xcode et créez un nouveau projet iOS basé sur le modèle d’application à vue unique. Nommez la liste d’accès de l’application et assurez-vous que l’option Utiliser les données de base est cochée.

En cochant la case Utiliser les données de base, Xcode générera un code standard pour ce que l’on appelle NSPersistentContainer dans AppDelegate.Swift.

Le NSPersistentContainer se compose d’un ensemble d’objets qui facilitent l’enregistrement et la récupération d’informations à partir de données de base. À l’intérieur de ce conteneur se trouve un objet pour gérer l’état des données de base dans son ensemble, un objet représentant le modèle de données, etc.

La pile standard fonctionne bien pour la plupart des applications, mais en fonction de votre application et de ses besoins en données, vous pouvez personnaliser la pile pour être plus efficace.

L’idée de cet exemple d’application est simple: il y aura une vue de table avec une liste de noms pour votre propre « liste de résultats ». Vous pourrez ajouter des noms à cette liste et éventuellement utiliser des données de base pour vous assurer que les données sont stockées entre les sessions. Nous ne tolérons pas la violence sur ce site, vous pouvez donc considérer cette application comme une liste de favoris pour garder une trace de vos amis aussi, bien sûr!

Cliquez sur Main.storyboard pour l’ouvrir dans Interface Builder. Sélectionnez le contrôleur de vue sur le canevas et intégrez-le dans un contrôleur de navigation. Dans le menu Éditeur de Xcode, sélectionnez Intégrer Dans Controller ▸ Contrôleur de Navigation.

Cliquez sur la barre de navigation du contrôleur de navigation pour le sélectionner, puis cliquez sur Préfère les grands titres dans l’Inspecteur des attributs. Cela donnera à l’exemple d’application un style de titre qui correspond aux applications boursières d’Apple.

Ensuite, faites glisser une vue de table de la bibliothèque d’objets dans le contrôleur de vue, puis redimensionnez-la pour qu’elle couvre toute la vue.

Si ce n’est pas déjà ouvert, utilisez l’icône située dans le coin inférieur gauche de votre canevas pour ouvrir le contour du document d’Interface Builder.

Ctrl – faites glisser la vue Table dans le contour du document vers sa vue parente et sélectionnez la contrainte Espace de tête vers Zone de sécurité:

Faites cela trois fois de plus, en sélectionnant les contraintes Espace de Fuite vers la Zone de Sécurité, Espace Supérieur vers la Zone de Sécurité et enfin, Espace Inférieur vers la Zone de Sécurité. L’ajout de ces quatre contraintes fera que la vue de table remplira sa vue parente.

Ensuite, faites glisser un élément de bouton de barre et placez-le sur la barre de navigation du contrôleur de vue. Enfin, sélectionnez l’élément bouton barre et modifiez son élément système pour ajouter.

Votre canevas devrait ressembler à la capture d’écran suivante:

Chaque fois que vous appuyez sur le bouton Ajouter, un contrôleur d’alerte contenant un champ de texte apparaît. À partir de là, vous pourrez taper le nom de quelqu’un dans le champ de texte. Appuyez sur Save pour enregistrer le nom, désactiver le contrôleur d’alerte et actualiser la vue de table, affichant tous les noms que vous avez entrés.

Mais d’abord, vous devez faire du contrôleur de vue la source de données de la vue de table. Dans le canevas, faites glisser Ctrl de la vue tableau vers l’icône du contrôleur de vue jaune au-dessus de la barre de navigation, comme indiqué ci-dessous, et cliquez sur Source de données:

Au cas où vous vous poseriez la question, vous n’avez pas besoin de configurer le délégué de la vue de table car taper sur les cellules ne déclenchera aucune action. Ça ne devient pas plus simple que ça!

Ouvrez l’assistant éditeur en appuyant sur Commande -Option-Entrée ou en sélectionnant le bouton du milieu du jeu d’outils de l’éditeur dans la barre Xcode.

Ctrl – faites glisser de la vue table sur ViewController.swift dans la définition de classe pour créer un IBOutlet.

Ensuite, nommez la nouvelle propriété IBOutlet tableView, ce qui donne la ligne suivante:

@IBOutlet weak var tableView: UITableView!

Ensuite, Ctrl – faites glisser le bouton Ajouter dans ViewController.swift juste en dessous de votre définition viewDidLoad(). Cette fois, créez une action au lieu d’une sortie, en nommant la méthode addName, avec un type UIBarButtonItem:

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

Vous pouvez maintenant vous référer à la vue de tableau et à l’action de l’élément de bouton de barre dans le code.

Ensuite, vous configurerez le modèle pour la vue de table. Ajoutez la propriété suivante à ViewController.rapide en dessous de la tableView IBOutlet:

var names: = 

names est un tableau mutable contenant des valeurs de chaîne affichées par la vue table. Ensuite, remplacez l’implémentation de viewDidLoad() par ce qui suit:

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

Cela définira un titre sur la barre de navigation et enregistrera la classe UITableViewCell avec la vue tableau.

Suivant, toujours dans ViewController.swift, ajoutez l’extension UITableViewDataSource suivante sous votre définition de classe pour 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 }}

Si vous avez déjà travaillé avec UITableView, ce code devrait sembler très familier. Vous renvoyez d’abord le nombre de lignes de la table comme le nombre d’éléments de votre tableau names.

Ensuite, tableView(_:cellForRowAt:) supprime les cellules de la vue de table et les remplit avec la chaîne correspondante du tableau names.

Ensuite, vous avez besoin d’un moyen d’ajouter de nouveaux noms afin que la vue table puisse les afficher. Implémentez la méthode addName IBAction que vous avez glissée Ctrl dans votre code plus tôt:

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

Chaque fois que vous appuyez sur le bouton Ajouter, cette méthode présentera un UIAlertController avec un champ de texte et deux boutons: Enregistrer et Annuler.

Save insère le texte actuel des champs de texte dans le tableau names puis recharge la vue table. Étant donné que le tableau names est le modèle sauvegardant la vue table, tout ce que vous tapez dans le champ de texte apparaîtra dans la vue table.

Enfin, créez et exécutez votre application pour la première fois. Ensuite, appuyez sur le bouton Ajouter. Le contrôleur d’alerte ressemblera à ceci:

Ajoutez quatre ou cinq noms à la liste. Vous devriez voir quelque chose de similaire à ci-dessous:

Votre vue de table affichera les données et votre tableau stockera les noms, mais la grande chose qui manque ici est la persistance. Le tableau est en mémoire, mais si vous forcez la fermeture de l’application ou redémarrez votre appareil, votre liste d’accès sera effacée. Les données de base offrent une persistance, ce qui signifie qu’elles peuvent stocker des données dans un état plus durable afin de survivre à une relance de l’application ou à un redémarrage de l’appareil.

Vous n’avez encore ajouté aucun élément de données de base, donc rien ne devrait persister une fois que vous vous êtes éloigné de l’application. Testons ça. Appuyez sur le bouton Accueil si vous utilisez un appareil physique ou l’équivalent (Maj+ H+H) si vous utilisez le Simulateur. Cela vous ramènera à la grille d’application familière sur l’écran d’accueil:

Depuis l’écran d’accueil, appuyez sur l’icône Liste d’accès pour ramener l’application au premier plan. Les noms sont toujours à l’écran. Qu’est-ce qui s’est passé?

Lorsque vous appuyez sur le bouton Accueil, l’application actuellement au premier plan passe à l’arrière-plan. Lorsque cela se produit, le système d’exploitation bloque tout ce qui se trouve actuellement en mémoire, y compris les chaînes du tableau names. De même, lorsqu’il est temps de se réveiller et de revenir au premier plan, le système d’exploitation restaure ce qui était en mémoire comme si vous n’étiez jamais parti.

Apple a introduit ces avancées dans le multitâche dans iOS 4. Ils créent une expérience transparente pour les utilisateurs iOS, mais ajoutent une ride à la définition de la persistance pour les développeurs iOS. Les noms sont-ils vraiment persistants?

Non, pas vraiment. Si vous aviez complètement tué l’application dans le sélecteur d’application rapide ou éteint votre téléphone, ces noms auraient disparu. Vous pouvez également le vérifier. Avec l’application au premier plan, entrez le sélecteur d’application rapide. Vous pouvez le faire en appuyant deux fois sur le bouton d’accueil si votre appareil en a un ou en faisant glisser lentement vers le haut depuis le bas de l’écran si vous êtes sur un iPhone X.

À partir de là, faites glisser l’instantané de l’application de liste d’accès vers le haut pour terminer l’application. Si vous travaillez sur un iPhone X, vous devez appuyer longuement sur l’instantané de l’application jusqu’à ce qu’un bouton de suppression rouge apparaisse en haut à droite.

Après avoir supprimé l’application du sélecteur d’applications, il ne devrait y avoir aucune trace de liste d’accès dans la mémoire vivante (sans jeu de mots). Vérifiez que les noms ont disparu en revenant à l’écran d’accueil et en appuyant sur l’icône de liste d’accès pour déclencher un nouveau lancement.

La différence entre le gel flash et la persistance peut être évidente si vous travaillez avec iOS depuis un certain temps et que vous connaissez le fonctionnement du multitâche. Dans l’esprit d’un utilisateur, cependant, il n’y a pas de différence. L’utilisateur se fiche de savoir pourquoi les noms sont toujours là, si l’application est passée en arrière-plan et est revenue, ou parce que l’application les a enregistrés et rechargés. Tout ce qui compte, c’est que les noms sont toujours là lorsque l’application revient!

Le véritable test de persistance est donc de savoir si vos données sont toujours là après le lancement d’une nouvelle application.

Modélisation de vos données

Maintenant que vous savez comment vérifier la persistance, vous pouvez plonger dans les données de base. Votre objectif pour l’application HitList est simple : conservez les noms que vous entrez afin qu’ils soient disponibles pour l’affichage après un nouveau lancement d’application.

Jusqu’à présent, vous utilisiez de vieilles chaînes Swift simples pour stocker les noms en mémoire. Dans cette section, vous remplacerez ces chaînes par des objets de données de base.

La première étape consiste à créer un modèle d’objet géré, qui décrit la façon dont les données de base représentent les données sur le disque.

Par défaut, Core Data utilise une base de données SQLite comme magasin persistant, vous pouvez donc considérer le modèle de données comme le schéma de base de données.

Puisque vous avez choisi d’utiliser Core Data, Xcode a automatiquement créé un fichier de modèle de données pour vous et l’a nommé Liste d’accès.xcdatamodèle.

Ouvrir la liste de résultats.xcdatamodèle. Comme vous pouvez le voir, Xcode dispose d’un puissant éditeur de modèle de données:

L’éditeur de modèle de données dispose de nombreuses fonctionnalités que vous pourrez explorer plus tard. Pour l’instant, concentrons-nous sur la création d’une seule entité de données de base.

Cliquez sur Ajouter une entité en bas à gauche pour créer une nouvelle entité. Double-cliquez sur la nouvelle entité et changez son nom en Personne, comme ceci:

Vous vous demandez peut-être pourquoi l’éditeur de modèle utilise le terme Entity. N’étiez-vous pas simplement en train de définir une nouvelle classe? Comme vous le verrez bientôt, Core Data est livré avec son propre vocabulaire. Voici un aperçu rapide de certains termes que vous rencontrerez couramment:

• Une entité est une définition de classe dans Core Data. L’exemple classique est un Employee ou un Company. Dans une base de données relationnelle, une entité correspond à une table.
• Un attribut est une information attachée à une entité particulière. Par exemple, une entité Employee peut avoir des attributs pour les name, position et salary de l’employé. Dans une base de données, un attribut correspond à un champ particulier d’une table.
• Une relation est un lien entre plusieurs entités. Dans les données de base, les relations entre deux entités sont appelées relations to-one, tandis que celles entre une et plusieurs entités sont appelées relations to-many. Par exemple, un Manager peut avoir une relation à plusieurs avec un ensemble d’employés, alors qu’un individu Employee aura généralement une relation à un avec son gestionnaire.

Maintenant que vous savez ce qu’est un attribut, vous pouvez ajouter un attribut à l’objet Person créé précédemment. Toujours dans la liste des résultats.xcdatamodeld, sélectionnez Person sur le côté gauche et cliquez sur le signe plus (+) sous Attributs.

Définissez le nom du nouvel attribut sur, er, name et changez son type en String:

Dans les données de base, un attribut peut être de l’un des plusieurs types de données.

Enregistrement dans les données de base

Ouvrez ViewController.rapide, ajoutez l’importation du module de données de base suivant sous l’importation UIKit:

import CoreData

Cette importation est tout ce dont vous avez besoin pour commencer à utiliser l’API Core Data dans votre code.

Ensuite, remplacez la définition de la propriété names par la suivante:

var people: = 

Vous stockerez des entités Person plutôt que des noms de chaînes, vous renommerez donc le tableau servant de modèle de données à la vue de table en people. Il contient désormais des instances de NSManagedObject plutôt que de simples chaînes.

NSManagedObject représente un objet unique stocké dans Core Data ; vous devez l’utiliser pour créer, modifier, enregistrer et supprimer de votre magasin persistant Core Data. Comme vous le verrez bientôt, NSManagedObject est un shape-shifter. Il peut prendre la forme de n’importe quelle entité de votre modèle de données, s’appropriant les attributs et les relations que vous avez définis.

Puisque vous modifiez le modèle de la vue de table, vous devez également remplacer les deux méthodes de source de données implémentées précédemment. Remplacez votre extension UITableViewDataSource par ce qui suit:

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

Le changement le plus significatif apporté à ces méthodes se produit dans tableView(_:cellForRowAt:). Au lieu de faire correspondre les cellules avec la chaîne correspondante dans le tableau de modèles, vous faites maintenant correspondre les cellules avec le NSManagedObject correspondant.

Notez comment vous récupérez l’attribut name à partir du NSManagedObject. Ça se passe ici:

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

Pourquoi tu dois faire ça ? Il s’avère que NSManagedObject ne connaît pas l’attribut name que vous avez défini dans votre modèle de données, il n’y a donc aucun moyen d’y accéder directement avec une propriété. La seule façon dont les données de base permettent de lire la valeur est le codage clé-valeur, communément appelé KVC.

Ensuite, recherchez addName(_:) et remplacez le save UIAlertAction par ce qui suit:

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

Cela prend le texte dans le champ de texte et le transmet à une nouvelle méthode nommée save(name:). Xcode se plaint car save(name:) n’existe pas encore. Ajoutez-le ci-dessous 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)") }}

C’est là que les données de base entrent en jeu! Voici ce que fait le code:

1. Avant de pouvoir enregistrer ou récupérer quoi que ce soit dans votre magasin de données principal, vous devez d’abord mettre la main sur un NSManagedObjectContext. Vous pouvez considérer un contexte d’objet géré comme un « bloc-notes » en mémoire pour travailler avec des objets gérés.

   Pensez à enregistrer un nouvel objet géré dans Core Data en deux étapes: tout d’abord, vous insérez un nouvel objet géré dans un contexte d’objet géré; une fois que vous êtes satisfait, vous « validez » les modifications de votre contexte d’objet géré pour l’enregistrer sur le disque.

   Xcode a déjà généré un contexte d’objet géré dans le cadre du modèle du nouveau projet. N’oubliez pas que cela ne se produit que si vous cochez la case Utiliser les données de base au début. Ce contexte d’objet géré par défaut est une propriété de NSPersistentContainer dans le délégué de l’application. Pour y accéder, vous obtenez d’abord une référence au délégué de l’application.

2. Vous créez un nouvel objet géré et l’insérez dans le contexte de l’objet géré. Vous pouvez le faire en une étape avec la méthode statique de NSManagedObject: entity(forEntityName:in:).

   Vous vous demandez peut-être en quoi consiste un NSEntityDescription. Rappelons plus tôt, NSManagedObject a été appelé une classe shape-shifter car elle peut représenter n’importe quelle entité. Une description d’entité est l’élément reliant la définition d’entité de votre modèle de données à une instance de NSManagedObject au moment de l’exécution.

1. Avec un NSManagedObject en main, vous définissez l’attribut name à l’aide d’un codage clé-valeur. Vous devez épeler la clé KVC (name dans ce cas) exactement comme elle apparaît dans votre modèle de données, sinon votre application se bloquera à l’exécution.
2. Vous validez vos modifications sur person et les enregistrez sur le disque en appelant save sur le contexte de l’objet géré. Remarque save peut générer une erreur, c’est pourquoi vous l’appelez en utilisant le mot-clé try dans un bloc do-catch. Enfin, insérez le nouvel objet géré dans le tableau people afin qu’il apparaisse lorsque la vue de table se recharge.

C’est un peu plus compliqué que d’utiliser un tableau de chaînes, mais pas trop mal. Une partie du code ici, comme l’obtention du contexte et de l’entité de l’objet géré, pourrait être effectuée une seule fois dans votre propre init() ou viewDidLoad() puis réutilisée plus tard. Pour plus de simplicité, vous faites tout cela selon la même méthode.

Créez et exécutez l’application, puis ajoutez quelques noms à la vue de table:

Si les noms sont réellement stockés dans Core Data, l’application Liste d’accès doit passer le test de persistance. Avec l’application au premier plan, accédez au sélecteur d’application rapide, puis terminez-le.

Depuis Springboard, appuyez sur l’application Liste d’accès pour déclencher un nouveau lancement. Attends, que s’est-il passé? La vue table est vide:

Vous avez enregistré dans Core Data, mais après un nouveau lancement d’application, le tableau people est vide! C’est parce que les données sont sur le disque qui vous attendent, mais vous ne les montrez pas encore.

Récupération à partir des données de base

Pour obtenir des données de votre magasin persistant dans le contexte d’objet géré, vous devez les récupérer. Ouvrez ViewController.swift et ajoutez les éléments suivants ci-dessous 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)") }}

Étape par étape, voici ce que fait le code:

1. Avant de pouvoir faire quoi que ce soit avec des données de base, vous avez besoin d’un contexte d’objet géré. Aller chercher n’est pas différent! Comme précédemment, vous tirez le délégué de l’application et saisissez une référence à son conteneur persistant pour mettre la main sur son NSManagedObjectContext.
2. Comme son nom l’indique, NSFetchRequest est la classe responsable de la récupération à partir des données de base. Les demandes de récupération sont à la fois puissantes et flexibles. Vous pouvez utiliser les requêtes fetch pour récupérer un ensemble d’objets répondant aux critères fournis (c’est-à-dire donnez-moi tous les employés vivant dans le Wisconsin et ayant travaillé avec l’entreprise au moins trois ans), des valeurs individuelles (c’est-à-dire donnez-moi le nom le plus long de la base de données) et plus encore.

   Les requêtes de récupération ont plusieurs qualificatifs utilisés pour affiner l’ensemble des résultats renvoyés. Pour l’instant, vous devez savoir que NSEntityDescription est l’un de ces qualificatifs requis.

   La définition de la propriété entity d’une requête de récupération, ou l’initialisation avec init(entityName:), récupère tous les objets d’une entité particulière. C’est ce que vous faites ici pour récupérer toutes les entités Person. Notez également que NSFetchRequest est un type générique. Cette utilisation de génériques spécifie le type de retour attendu d’une demande de récupération, dans ce cas NSManagedObject.

3. Vous transmettez la demande de récupération au contexte de l’objet géré pour effectuer le gros du travail. fetch(_:) renvoie un tableau d’objets gérés répondant aux critères spécifiés par la requête fetch.

Créez et exécutez l’application. Immédiatement, vous devriez voir la liste des noms que vous avez ajoutés plus tôt:

Super ! Ils sont revenus d’entre les morts (jeu de mots). Ajoutez quelques noms supplémentaires à la liste et redémarrez l’application pour vérifier que l’enregistrement et la récupération fonctionnent. À moins de supprimer l’application, de réinitialiser le simulateur ou de jeter votre téléphone d’un grand bâtiment, les noms apparaîtront dans la vue de table quoi qu’il arrive.

Points clés

• Core Data assure la persistance sur le disque, ce qui signifie que vos données seront accessibles même après la fermeture de votre application ou la fermeture de votre appareil. Ceci est différent de la persistance en mémoire, qui n’enregistrera vos données que tant que votre application est en mémoire, au premier plan ou en arrière-plan.
• Xcode est livré avec un puissant éditeur de modèle de données, que vous pouvez utiliser pour créer votre modèle d’objet géré.
• Un modèle d’objet géré est composé d’entités, d’attributs et de relations
• Une entité est une définition de classe dans Core Data.
• Un attribut est une information attachée à une entité.
• Une relation est un lien entre plusieurs entités.
• Et NSManagedObject est une représentation à l’exécution d’une entité de données de base. Vous pouvez lire et écrire sur ses attributs à l’aide d’un codage Clé-valeur.
• Vous avez besoin de données NSManagedObjectContext à save() ou fetch(_:) vers et depuis les données de base.

Où aller D’Ici?

Vous pouvez télécharger le projet terminé pour ce tutoriel en utilisant les boutons « Télécharger les matériaux » en haut ou en bas de ce tutoriel.

Dans ce tutoriel, vous avez déjà expérimenté plusieurs concepts fondamentaux de données de base : Modèles de données, entités, attributs, objets gérés, contextes d’objets gérés et requêtes de récupération.

Si vous avez apprécié ce que vous avez appris dans ce tutoriel, pourquoi ne pas consulter le livre complet de données de base par Tutoriels, disponible dans notre magasin?

Voici un avant-goût de ce qui se trouve dans le livre:

1. Chapitre 1, Votre première application de données de base: Vous cliquez sur Fichier ▸ Nouveau projet et écrivez une application de données de base à partir de zéro! Ce chapitre couvre les bases de la configuration de votre modèle de données, puis de l’ajout et de la récupération d’enregistrements.

2. Chapitre 2, Sous-classes NSManagedObject : NSManagedObject est la classe de stockage de données de base de vos graphiques d’objets de données principaux. Ce chapitre vous apprendra comment personnaliser vos propres sous-classes d’objets gérés pour stocker et valider des données.

3. Chapitre 3, La pile de données de base: Sous le capot, les données de base sont composées de nombreuses parties travaillant ensemble. Dans ce chapitre, vous apprendrez comment ces pièces s’emboîtent et vous éloignerez du modèle starter Xcode pour créer votre propre système personnalisable.

4. Chapitre 4, Récupération intermédiaire : Vos applications récupéreront les données tout le temps, et Core Data offre de nombreuses options pour vous les transmettre efficacement. Ce chapitre couvre les demandes de récupération plus avancées, les prédicats, le tri et la récupération asynchrone.

5. Chapitre 5, NSFetchedResultsController: Les vues de table sont au cœur de nombreuses applications iOS, et Apple veut faire en sorte que les données de base jouent bien avec elles! Dans ce chapitre, vous apprendrez comment NSFetchedResultsController peut vous faire gagner du temps et du code lorsque vos vues de table sont sauvegardées par des données de Core Data.

6. Chapitre 6, Gestion des versions et migration : À mesure que vous mettez à jour et améliorez votre application, son modèle de données devra presque certainement changer. Dans ce chapitre, vous apprendrez à créer plusieurs versions de votre modèle de données, puis à migrer vos utilisateurs vers l’avant afin qu’ils puissent conserver leurs données existantes lors de la mise à niveau.

7. Chapitre 7, Tests unitaires: Les tests sont une partie importante du processus de développement, et vous ne devriez pas laisser les données de base en dehors de cela! Dans ce chapitre, vous apprendrez à configurer un environnement de test distinct pour les données de base et à voir des exemples de test de vos modèles.

8. Chapitre 8, Mesure et amélioration des performances: Personne ne s’est jamais plaint qu’une application était trop rapide, il est donc important d’être vigilant sur les performances de suivi. Dans ce chapitre, vous apprendrez à mesurer les performances de votre application avec divers outils Xcode, puis à trouver quelques conseils pour gérer les zones lentes de votre code.

9. Chapitre 9, Contextes d’objets gérés multiples : Dans ce dernier chapitre, vous développerez la pile de données de base habituelle pour inclure plusieurs contextes d’objets gérés. Vous apprendrez comment cela peut améliorer les performances perçues et aider à rendre l’architecture de votre application moins monolithique et plus compartimentée.

Et pour aider à adoucir l’affaire, l’édition numérique du livre est en vente pour 44,99 $! Mais n’attendez pas — ce prix de vente n’est disponible que pour une durée limitée.

En parlant de bonnes affaires, n’oubliez pas de jeter un coup d’œil aux superbes prix que nous remettons cette année lors de la soirée de lancement d’iOS 11, dont plus de 9 000 giv en cadeaux!

Pour être éligible à ce concours épique iOS 12, il vous suffit de laisser un commentaire sur le message de lancement original, en nous indiquant quel livre ou cours est votre favori sur cette liste — ou quel livre ou cours à venir vous passionne le plus!

Nous espérons que vous apprécierez cette mise à jour, et restez à l’écoute pour plus de sorties et de mises à jour de livres!