Getting Started with Core Data Tutorial

This is an abridged chapter from our book Core Data by Tutorials, which has been completely updated for Swift 4.2 and iOS 12. Este tutorial é apresentado como parte da nossa festa de lançamento iOS 12-enjoy!

Bem-vindo aos Dados Principais!

neste tutorial, você vai escrever seu primeiro aplicativo de dados Core. Você verá como é fácil começar com todos os recursos fornecidos no Xcode, desde modelos de código inicial até o editor de modelos de dados.Vai bater no chão a correr desde o início. No final do tutorial você saberá como:

• Model data using Xcode’s model editor
• Add new records to Core Data
• Fetch a set of records from Core Data
• Display the fetched records using a table view.

você também terá uma noção do que os dados do núcleo estão fazendo nos bastidores, e como você pode interagir com as várias peças em movimento.

iniciar

abrir o Xcode e criar um novo projecto iOS com base no modelo Single View App. Indique a lista de aplicações e certifique-se de usar os dados do Core estão verificados.

a verificação da caixa de dados de Uso do Core fará com que o Xcode gere o código boilerplate para o que é conhecido como um NSPersistentContainer no AppDelegate.rapido.

o NSPersistentContainer consiste num conjunto de objectos que facilitam a poupança e a obtenção de informações a partir de dados essenciais. Dentro deste recipiente está um objeto para gerenciar o estado de dados do núcleo como um todo, um objeto que representa o modelo de dados, e assim por diante.

a pilha padrão funciona bem para a maioria dos aplicativos, mas dependendo de seu aplicativo e seus requisitos de dados, você pode personalizar a pilha para ser mais eficiente.

a ideia para este aplicativo de amostra é simples: haverá uma tabela com uma lista de nomes para a sua própria “lista de sucesso”. Você será capaz de adicionar nomes a esta lista, e eventualmente, usar dados do núcleo para se certificar de que os dados são armazenados entre sessões. Nós NÃO apoiamos a violência neste site, então você pode pensar neste aplicativo como uma lista de favoritos para manter o controle de seus amigos também, é claro!

clique no botão principal.storyboard para abri-lo no Construtor de interfaces. Seleccione o controlador de visualização na área de desenho e introduza-o dentro de um controlador de navegação. Do menu Editor do Xcode, seleccione a opção Incorporar no controlador de navegação…▸.

clique na barra de navegação do controlador de navegação para selecioná-lo, em seguida, clique em prefere grandes títulos no Inspector de atributos. Isto dará ao aplicativo de exemplo um estilo de título que corresponde às aplicações de estoque da Apple.

em seguida, arraste uma vista de tabela da biblioteca de objetos para o controlador de vista, em seguida, redimensioná-la para que cubra toda a vista.

se ainda não estiver aberto, use o ícone localizado no canto inferior esquerdo da sua área de desenho para abrir o contorno do documento do Construtor de interfaces.

Ctrl-drag da tabela no contorno do documento para a sua área-mãe e seleccionar o espaço inicial para a restrição de área segura:

faça isso mais três vezes, selecionando as restrições que seguem o espaço para a área segura, o espaço superior para a área segura e, finalmente, o espaço inferior para a área segura. A adição dessas quatro restrições fará com que a tabela view preencha a sua área-mãe.

em seguida, arraste um Item do botão de Barra e coloque-o na barra de navegação do controlador de visualização. Finalmente, selecione o item do botão de barra e altere o item do sistema para adicionar.

a sua tela deve ser semelhante à imagem seguinte:

sempre que carregar no botão Adicionar, irá aparecer um controlador de alerta que contém um campo de texto. A partir daí, você será capaz de digitar o nome de alguém no campo de texto. Se tocar no Save irá gravar o nome, desligar o controlador de alerta e actualizar a janela da tabela, mostrando todos os nomes que introduziu.

mas primeiro, você precisa fazer do controlador de vista a fonte de dados da tabela view. Na área de desenho, O Ctrl-drag da janela da tabela para o ícone do controlador de vista amarela por cima da barra de navegação, como é mostrado em baixo, e carregue no dataSource:

no caso de você estar se perguntando, Você não precisa configurar o delegado da tabela view já que bater nas células não vai desencadear nenhuma ação. Não fica mais simples do que isto!

abra o editor assistente pressionando a opção de comando-Enter ou seleccionando o botão do meio na Ferramenta do Editor na barra de Xcode.

Ctrl-drag da tabela para Vercontrolador.swift inside the class definition to create an IBOutlet.

em seguida, nomeie a nova propriedade IBOutlet tableView, resultando na seguinte linha:

@IBOutlet weak var tableView: UITableView!

a seguir, Ctrl-drag do botão Adicionar para Vercontrolador.swift logo abaixo da sua definição viewDidLoad(). Desta vez, crie uma ação em vez de uma saída, nomeando o método addName, com um tipo UIBarButtonItem:

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

você pode agora se referir à janela da tabela e à ação do item do botão de barra em código.

em seguida, você vai configurar o modelo para a vista de tabela. Adicione a seguinte propriedade ao Vercontroller.swift abaixo do tableView IBOutlet:

var names: = 

names é uma matriz mutável que contém os valores de texto mostrados pela janela da tabela. Em seguida, substituir a implementação de viewDidLoad() pelo seguinte:

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

isto irá definir um título na barra de navegação e registar a classe UITableViewCell com a vista da tabela.

Next, still in ViewController.swift, adicione a seguinte extensão UITableViewDataSource abaixo da sua definição de classe para 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 você já trabalhou com UITableView , este código deve parecer muito familiar. Primeiro você devolve o número de linhas na tabela como o número de itens em seu array names.

a seguir, tableView(_:cellForRowAt:) denuncia as células de visualização da tabela e populaliza – as com a cadeia correspondente da matriz names.

em seguida, você precisa de uma maneira de adicionar novos nomes para que a janela de tabela possa mostrá-los. Implementar o método addName IBAction que Ctrl-arrastou para o seu código mais cedo:

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

sempre que carregar no botão Adicionar, este método irá apresentar um UIAlertController com um campo de texto e dois botões: gravar e cancelar.

Save insere os campos de texto texto texto actual no array names depois carrega a janela da tabela. Uma vez que o array names é o modelo que suporta a janela da tabela, o que quer que escreva no campo de texto irá aparecer na janela da tabela.Finalmente, construa e execute a sua aplicação pela primeira vez. Em seguida, toque no botão Adicionar. O controlador de alerta será assim:

adicione quatro ou cinco nomes à lista. Você deve ver algo semelhante ao abaixo:

a sua vista de mesa irá mostrar os dados e o seu array irá armazenar os nomes, mas a grande coisa que falta aqui é a persistência. A matriz está na memória, mas se você forçar sair do aplicativo ou reiniciar o seu dispositivo, a sua lista de hit será apagada. Os dados do núcleo fornecem persistência, o que significa que ele pode armazenar dados em um estado mais durável para que ele possa sobreviver a um re-lançamento do aplicativo ou um reboot de dispositivo.

ainda não adicionou nenhum elemento de dados de base, por isso nada deverá persistir depois de navegar para longe da aplicação. Vamos testar isto. Carregue no botão Home se estiver a usar um dispositivo físico ou o equivalente (Shift + ⌘ + H) se estiver a usar o simulador. Isto irá levá-lo de volta para a grelha de aplicações familiar no ecrã inicial:

a partir da tela inicial, Toque no ícone HitList para trazer o aplicativo de volta para o primeiro plano. Os nomes ainda estão no ecrã. O que houve?

quando você toca no botão Home, a aplicação de momento em primeiro plano vai para o fundo. Quando isso acontece, o flash do sistema operacional congela tudo atualmente na memória, incluindo as cadeias de caracteres na matriz de nomes. Da mesma forma, quando é hora de acordar e voltar para o primeiro plano, o sistema operacional restaura o que costumava estar na memória como se você nunca tivesse saído.

a Apple introduziu estes avanços em multitarefas de volta no iOS 4. Eles criam uma experiência perfeita para os usuários do iOS, mas adicionam uma ruga à definição de persistência para os desenvolvedores do iOS. Os nomes persistem mesmo?Não, nem por isso. Se tivesses matado completamente o aplicativo no interruptor rápido ou desligado o teu telemóvel, esses nomes teriam desaparecido. Você pode verificar isso também. Com a aplicação em primeiro plano, indique o selector de aplicações rápido. Você pode fazer isso com um duplo toque no botão Home e, se o seu dispositivo tem um ou lentamente, arrastando para cima a partir da parte inferior da tela, se você estiver em um iPhone X.

a Partir daqui, mexa a tela para a lista de Contratos aplicativo instantâneo para cima para encerrar o aplicativo. Se você está trabalhando em um iPhone X, você tem que carregar a longo prazo no Instantâneo da aplicação até que um botão vermelho apagar aparece na parte superior direita.

depois de remover a aplicação do selector de aplicações, não deverá haver vestígios de HitList na memória viva (sem trocadilhos). Verifique se os nomes se foram, retornando ao ecrã inicial e tocando no ícone HitList para desencadear um novo lançamento.

a diferença entre congelamento em flash e persistência pode ser óbvia se você trabalhou com iOS por algum tempo e está familiarizado com a forma como as multitarefas funcionam. Na mente de um usuário, no entanto, não há diferença. O Usuário não se importa por que os nomes ainda estão lá, se o aplicativo foi para o fundo e voltou, ou porque o aplicativo salvou e recarregou-os. Tudo o que importa é que os nomes ainda estão lá quando o aplicativo volta!

então o verdadeiro teste de persistência é se seus dados ainda estão lá após um novo lançamento do aplicativo.Agora você sabe como verificar a persistência, você pode mergulhar em dados centrais. Seu objetivo para a aplicação HitList é simples: persistir os nomes que você digite para que eles estejam disponíveis para visualização após um novo lançamento da aplicação.Até este momento, você tem usado cordas Swift simples e antigas para armazenar os nomes em memória. Nesta secção, irá substituir estas cadeias de caracteres por objectos de dados centrais.

o primeiro passo é criar um modelo de objeto gerenciado, que descreve a forma como os dados do núcleo representam os dados no disco.

por padrão, os dados do núcleo usam um banco de dados SQLite como a store persistente, então você pode pensar no modelo de dados como o esquema de banco de dados.

desde que você optou por usar dados de base, o Xcode automaticamente criou um arquivo de modelo de dados para você e o nomeou HitList.xcdatamodeld.

Lista Aberta.xcdatamodeld. Como você pode ver, Xcode tem um editor poderoso modelo de dados:

o editor de modelos de dados tem um monte de recursos que você pode explorar mais tarde. Por agora, vamos nos concentrar em criar uma única entidade de dados do núcleo.

clique em Adicionar entidade na parte inferior esquerda para criar uma nova entidade. Clique duas vezes na nova entidade e mude o seu nome para pessoa, assim:

você pode estar se perguntando Por que o editor modelo usa o termo Entity. você não estava simplesmente definindo uma nova classe? Como verá em breve, os dados centrais vêm com o seu próprio vocabulário. Aqui está um resumo rápido de alguns termos que você geralmente encontrar:

• uma entidade é uma definição de classe em dados centrais. O exemplo clássico é um Employee ou um Company. Em um banco de dados relacional, uma entidade corresponde a uma tabela.
• um atributo é uma informação ligada a uma determinada entidade. Por exemplo, uma entidade Employee poderia ter atributos para os empregados name, position e salary. Em um banco de dados, um atributo corresponde a um campo particular em uma tabela.
• uma relação é uma ligação entre várias entidades. Em dados centrais, as relações entre duas entidades são chamadas para-um relacionamento, enquanto as relações entre uma e muitas entidades são chamadas para-muitos relacionamentos. Por exemplo, um Manager pode ter uma relação de muitos com um conjunto de empregados, enquanto um indivíduo Employee normalmente tem uma relação de um para um com o seu gerente.

Now you know what an attribute is, you can add an attribute to Person object created earlier. Ainda está no HitList.xcdatamodeld, seleccione Person do lado esquerdo e carregue no sinal + ( + ) sob os atributos.

define o nome do novo atributo como, er, nome e muda o seu tipo para String:

em Dados Principais, um atributo pode ser de um dos vários tipos de dados.

poupança para dados de base

Open ViewController.swift, adicione a importação do seguinte módulo de dados de Base abaixo da importação UIKit :

import CoreData

esta importação é tudo o que você precisa para começar a usar a API de dados do núcleo em seu código.

em seguida, substituir a definição de propriedade names pela seguinte::

var people: = 

você vai armazenar Person entidades em vez de nomes de cordas, então você renomeia o array servindo como modelo de dados da tabela view para people. Ele agora detém instâncias de NSManagedObject ao invés de cordas simples.

NSManagedObject representa um único objecto armazenado em dados de base; você deve usá-lo para criar, editar, gravar e apagar do seu armazenamento persistente de dados de base. Como verá em breve, NSManagedObject é um metamorfo. Pode assumir a forma de qualquer entidade em seu modelo de dados, apropriando-se de quaisquer atributos e relacionamentos que você definiu.

uma vez que você está mudando o modelo da tabela view, Você também deve substituir ambos os métodos de fonte de dados implementados anteriormente. Substitua a sua extensão UITableViewDataSource pelo seguinte:

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

a alteração mais significativa destes métodos ocorre em tableView(_:cellForRowAt:). Em vez de combinar as células com o texto correspondente na lista de modelos, você agora corresponde as células com o correspondente NSManagedObject.

Note Como você pega o atributo name do NSManagedObject. Acontece aqui.:

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

porque tens de fazer isto? Como acontece, NSManagedObject não sabe sobre o atributo name que você definiu em seu modelo de dados, então não há maneira de acessá-lo diretamente com uma propriedade. A única maneira que os dados do Core fornecem para ler o valor é a codificação do valor-chave, comumente referido como KVC.

a seguir, encontrar addName(_:) e substituir o save UIAlertAction pelo seguinte:

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

isto leva o texto no campo de texto e passa-o para um novo método chamado save(name:). Xcode reclama porque save(name:) ainda não existe. Adiciona-o abaixo 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)") }}

é aqui que os dados centrais entram em acção! Aqui está o que o código faz.:

1. antes que você possa salvar ou recuperar qualquer coisa do seu núcleo de dados, você primeiro precisa começar suas mãos em um NSManagedObjectContext. Você pode considerar um contexto de objeto gerenciado como um “scratchpad” em memória para trabalhar com objetos gerenciados.

   pense em Salvar um novo objeto gerenciado para os dados do núcleo como um processo de duas etapas: primeiro, você insere um novo objeto gerenciado em um contexto de objeto gerenciado; uma vez que você está feliz, você “commit” as alterações no seu contexto de objeto gerenciado para salvá-lo em disco.

   Xcode já gerou um contexto de objeto gerenciado como parte do modelo do novo projeto. Lembre-se, isso só acontece se você verificar a opção Usar dados do núcleo no início. Este contexto de objeto gerenciado padrão vive como uma propriedade do NSPersistentContainer no delegado de Aplicação. Para acessá-lo, você primeiro obter uma referência ao delegado app.

2. cria um novo objecto gerido e insere-o no contexto do objecto gerido. Você pode fazer isso em um passo com o método estático NSManagedObject: entity(forEntityName:in:).Pode estar a perguntar-se sobre o que é um NSEntityDescription. Recall earlier, NSManagedObject was called a shape-shifter class because it can represent any entity. Uma descrição de entidade é a peça que liga a definição de entidade do seu modelo de dados com uma instância de NSManagedObject em tempo de execução.

1. com um NSManagedObject na mão, Você define o atributo name usando a codificação do valor-chave. Tem de soletrar a chave KVC (name neste caso) exactamente como aparece no seu modelo de dados, caso contrário, a sua aplicação irá estoirar à hora de execução.
2. envia as suas alterações para person e grava para o disco, chamando save no contexto do objecto gerido. Nota save pode lançar um erro, e é por isso que você o chama usando a palavra-chave try dentro de um bloco do-catch. Finalmente, insira o novo objeto gerenciado no array people para que ele apareça quando a janela da tabela recarrega.

isso é um pouco mais complicado do que usar um conjunto de cordas, mas não muito ruim. Alguns dos códigos aqui, como obter o contexto de objeto gerenciado e entidade, poderia ser feito apenas uma vez em seu próprio init() ou viewDidLoad(), então reutilizado mais tarde. Por simplicidade, você está fazendo tudo no mesmo método.

compilar e executar a aplicação, e adicionar alguns nomes à janela da tabela:

se os nomes são realmente armazenados em dados centrais, o aplicativo HitList deve passar no teste de persistência. Com o aplicativo em primeiro plano, vá para o switcher de aplicativos rápidos e, em seguida, terminá-lo.

do Springboard, toque na aplicação HitList para desencadear um novo lançamento. Espera, o que aconteceu? A janela da tabela está vazia:

você gravou para os dados do núcleo, mas depois de um novo lançamento do aplicativo, o array people está vazio! Isso é porque os dados estão sentados no disco esperando por você, mas você não está mostrando ainda.Para obter dados da sua loja persistente no contexto do objecto gerido, terá de O obter. Abra O Controle De Visualização.swift e adicione o seguinte abaixo 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 a passo, isto é o que o código faz:

1. Antes de poder fazer qualquer coisa com dados centrais, precisa de um contexto de objecto gerido. Buscar não é diferente! Como antes, você puxa o delegado da aplicação e pega uma referência ao seu contêiner persistente para colocar suas mãos em seu NSManagedObjectContext.
2. como o nome sugere, NSFetchRequest é a classe responsável pela obtenção de dados do núcleo. Os pedidos de busca são poderosos e flexíveis. Você pode usar os pedidos de busca para obter um conjunto de objetos que cumpram os critérios fornecidos (i.e. dê – me todos os funcionários que vivem em Wisconsin e têm estado com a empresa pelo menos três anos), valores individuais (ou seja, dê-me o nome mais longo na base de dados) e muito mais.

   os pedidos de busca têm vários qualificadores usados para refinar o conjunto de resultados retornados. Por agora, você deve saber NSEntityDescription é um desses qualificadores necessários.

   definir a propriedade de um pedido de busca entity, ou, alternativamente, inicializá-lo com init(entityName:), obtém todos os objetos de uma determinada entidade. Isto é o que você faz aqui para obter todas as entidades Person. Também nota NSFetchRequest é um tipo genérico. Este uso de genéricos especifica o tipo de retorno esperado de um pedido de busca, neste caso NSManagedObject.

3. entrega o pedido de obtenção para o contexto do objecto gerido para fazer o trabalho pesado. fetch(_:) devolve uma lista de objectos geridos que satisfazem os critérios especificados pelo pedido de obtenção.

Construa e execute a aplicação. Imediatamente, você deve ver a lista de nomes que você adicionou antes:

óptimo! Voltaram dos mortos. Adicione mais alguns nomes à lista e reinicie a aplicação para verificar se a gravação e a obtenção estão a funcionar. A não ser apagar a aplicação, reiniciar o simulador ou atirar o seu telemóvel de um edifício alto, os nomes irão aparecer na vista da mesa, aconteça o que acontecer.

pontos chave

• os dados de base fornecem persistência em disco, o que significa que os seus dados serão acessíveis mesmo depois de terminar o seu aplicativo ou desligar o seu dispositivo. Isto é diferente da persistência na memória, que só irá salvar os seus dados enquanto o seu aplicativo está na memória, seja em primeiro plano ou em segundo plano.
• Xcode vem com um poderoso editor de modelos de dados, que você pode usar para criar o seu modelo de objeto gerenciado.
• um modelo de objeto gerenciado é composto por entidades, atributos e relacionamentos
• uma entidade é uma definição de classe em dados de base.
• um atributo é uma informação ligada a uma entidade.
• uma relação é uma ligação entre várias entidades.
• An NSManagedObject é uma representação em tempo de execução de uma entidade de dados de base. Você pode ler e escrever para os seus atributos usando codificação chave-valor.
• necessita de dados NSManagedObjectContext a save() ou fetch(_:) de e para os dados principais.

para onde ir a partir daqui?

pode transferir o projecto completo para este tutorial usando os botões “Transferir materiais” no topo ou no fundo deste tutorial.

neste tutorial, você já experimentou vários conceitos fundamentais de Dados: Modelos de Dados, entidades, atributos, objetos gerenciados, contextos de objetos gerenciados e solicitações de busca.

se você gostou do que você aprendeu neste tutorial, por que não conferir os dados do núcleo completo pelo livro tutorial, disponível em nossa loja?Aqui está uma amostra do que está no livro:

1. Capítulo 1, o seu primeiro aplicativo de dados Core: você vai clicar em Arquivo ▸ Novo Projeto e escrever um aplicativo de dados Core do zero! Este capítulo cobre o básico de configurar o seu modelo de dados e, em seguida, adicionar e obter registros.

2. Capítulo 2, Subclasses de NSManagedObject: NSManagedObject é a classe de armazenamento de dados de base de seus gráficos de objetos de dados de base. Este capítulo irá ensinar-lhe como personaliza as suas subclasses de objectos geridos para armazenar e validar dados.

3. Capítulo 3, a pilha de dados do núcleo: sob o capô, os dados do núcleo são compostos de muitas partes trabalhando em conjunto. Neste capítulo, você vai aprender sobre como essas partes se encaixam, e se afastar do modelo starter Xcode para construir o seu próprio sistema personalizável.

4. Capítulo 4, obtenção intermediária: seus aplicativos irão buscar dados o tempo todo, e os dados do núcleo oferecem muitas opções para obter os dados para você de forma eficiente. Este capítulo cobre os pedidos de busca mais avançados, predicados, ordenação e busca assíncrona.

5. Chapter 5, NSFetchedResultsController: Table views are at the core of many iOS apps, and Apple wants to make Core Data play nicely with them! Neste capítulo, você vai aprender como o NSFetchedResultsController pode economizar tempo e código quando suas visualizações de tabela são suportadas por dados de dados centrais.

6. Capítulo 6, versionamento e migração: à medida que você atualizar e melhorar o seu aplicativo, seu modelo de dados vai quase certamente precisar mudar. Neste capítulo, você vai aprender como criar várias versões do seu modelo de dados e, em seguida, migrar seus usuários para a frente para que eles possam manter seus dados existentes à medida que atualizam.

7. Capítulo 7, Testes Unitários: o teste é uma parte importante do processo de desenvolvimento, e você não deve deixar os dados centrais fora disso! Neste capítulo, você vai aprender como configurar um ambiente de teste separado para os dados centrais e ver exemplos de como testar seus modelos.

8. Capítulo 8, Medição e reforço do desempenho: Nunca ninguém reclamou que um aplicativo era muito rápido, então é importante estar vigilante sobre o desempenho de rastreamento. Neste capítulo, você vai aprender a medir o desempenho do seu aplicativo com várias ferramentas Xcode e, em seguida, pegar algumas dicas para lidar com pontos lentos em seu código.

9. Capítulo 9, múltiplos contextos de objetos gerenciados: neste último capítulo, você vai expandir a pilha de dados do núcleo usual para incluir múltiplos contextos de objetos gerenciados. Você aprenderá como isso pode melhorar o desempenho percebido e ajudar a tornar sua arquitetura app menos monolítica e mais compartimentada.

e para ajudar a adoçar o negócio, a edição digital do livro está à venda por $44.99! Mas não espere — este preço de venda está disponível apenas por um tempo limitado.Por falar em negócios doces, Não se esqueça de verificar os grandes prémios que estamos a dar este ano com a festa de lançamento do iOS 11, incluindo mais de 9 mil dólares em doações!

para ser elegível para este épico iOS 12 giveaway, tudo o que você tem a fazer é deixar um comentário sobre o lançamento original, nos deixando saber qual livro ou curso é o seu favorito nesta lista — ou que próximo livro ou curso você está mais animado!

esperamos que goste desta atualização, e fique sintonizado para mais lançamentos e atualizações de livros!