21.11.2024

Aula 96: Persistência de Dados com Core Data e SwiftUI

Em aplicações modernas de SwiftUI, gerenciar dados de forma eficiente é crucial. Uma das maneiras mais populares de alcançar a persistência em aplicativos iOS é utilizando o Core Data. O Core Data é um framework poderoso que permite aos desenvolvedores gerenciar os objetos da camada de modelo em suas aplicações. Nesta aula, vamos explorar como integrar o Core Data com SwiftUI para persistir e recuperar dados de forma fluida.

Começando

Antes de mergulhar na implementação, certifique-se de que você criou um novo projeto SwiftUI no Xcode. Siga estes passos:

1. Abra o Xcode e crie um novo projeto SwiftUI.
2. Marque a opção "Usar Core Data" ao criar o projeto.

Isso gerará a configuração básica do Core Data, incluindo um NSPersistentContainer e um modelo de dados de exemplo.

Configurando o Modelo do Core Data

1. Navegue até o arquivo .xcdatamodeld no seu projeto.
2. Crie uma nova entidade chamada Item com os seguintes atributos:
   • nome: String
   • timestamp: Date

Salve suas alterações.

Criando a Stack do Core Data

No arquivo Persistence.swift gerado pelo template, você encontrará uma struct chamada PersistenceController, que contém a configuração da stack do Core Data. Aqui está como ela se parece:

import CoreData

struct PersistenceController {
    static let shared = PersistenceController()

    let container: NSPersistentContainer

    init(inMemory: Bool = false) {
        container = NSPersistentContainer(name: "NomeDoSeuProjeto")

        if inMemory {
            container.persistentStoreDescriptions.first?.url = URL(fileURLWithPath: "/dev/null")
        }

        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Erro não resolvido \(error), \(error.userInfo)")
            }
        })
    }
}

Criando uma View SwiftUI com Core Data

Agora, vamos criar uma view SwiftUI que interage com o Core Data. Vamos construir um aplicativo simples que permite aos usuários adicionar itens e visualizar uma lista desses itens.

Passo 1: Criando a View da Lista de Itens

Crie uma nova view SwiftUI chamada ItemListView.swift:

import SwiftUI

struct ItemListView: View {
    @FetchRequest(
        entity: Item.entity(),
        sortDescriptors: [NSSortDescriptor(keyPath: \Item.timestamp, ascending: true)]
    ) var items: FetchedResults<Item>

    @Environment(\.managedObjectContext) private var viewContext

    var body: some View {
        NavigationView {
            List {
                ForEach(items, id: \.self) { item in
                    Text(item.nome ?? "Desconhecido")
                }
                .onDelete(perform: deleteItems)
            }
            .navigationTitle("Itens")
            .navigationBarItems(trailing: Button(action: addItem) {
                Label("Adicionar Item", systemImage: "plus")
            })
        }
    }

    private func addItem() {
        withAnimation {
            let newItem = Item(context: viewContext)
            newItem.timestamp = Date()
            newItem.nome = "Novo Item"

            do {
                try viewContext.save()
            } catch {
                // Trate o erro de forma apropriada
                print("Erro ao salvar contexto: \(error.localizedDescription)")
            }
        }
    }

    private func deleteItems(at offsets: IndexSet) {
        withAnimation {
            offsets.map { items[$0] }.forEach(viewContext.delete)

            do {
                try viewContext.save()
            } catch {
                // Trate o erro de forma apropriada
                print("Erro ao deletar contexto: \(error.localizedDescription)")
            }
        }
    }
}

Passo 2: Integrando ItemListView no App

Agora, abra o arquivo principal do seu aplicativo (geralmente chamado NomeDoSeuProjetoApp.swift) e atualize-o para usar o ItemListView:

import SwiftUI

@main
struct NomeDoSeuProjetoApp: App {
    let persistenceController = PersistenceController.shared

    var body: some Scene {
        WindowGroup {
            ItemListView()
                .environment(\.managedObjectContext, persistenceController.container.viewContext)
        }
    }
}

Conclusão

Parabéns! Você integrou com sucesso o Core Data com o SwiftUI para criar um aplicativo simples que permite aos usuários adicionar e remover itens. Nesta aula, abordamos:

1. Configuração de um modelo Core Data.
2. Criação de uma view SwiftUI que busca e exibe entidades do Core Data.
3. Implementação de funcionalidades para adicionar e deletar itens no banco de dados.

Com esta base, você pode expandir seu aplicativo adicionando modelos de dados mais complexos, relacionamentos e várias views. O Core Data oferece uma solução robusta para persistir e gerenciar dados em suas aplicações SwiftUI. Boas codificações!

Video

Navigation