Core Data for Beginners: A Step-by-Step Guide

1. What is Core Data?

Core Data is a framework provided by Apple that allows you to persist (save) data locally. It is not a database like SQLite but can use SQLite as its backend. Core Data manages objects and relationships, making it easier to handle large amounts of data efficiently.

2. Setting Up Core Data in a SwiftUI Project

1. Create a New Project:

   • Open Xcode.
   • Select App and click "Next."
   • Enter a name for your app, e.g., CoreDataDemo.
   • Ensure "Use Core Data" is checked.

2. Explore the Project Structure:
   When you enable Core Data, Xcode automatically sets up:

   • CoreDataDemoApp.swift - The app's entry point.
   • PersistenceController.swift - A file that sets up the Core Data stack.

3. Understanding the Core Data Stack

Core Data involves the following key components:

• Persistent Container: The heart of Core Data, which manages the database and the object context.
• Managed Object Context (MOC): An environment to create, read, update, and delete objects.
• Entity: The "table" structure of your data model.
• Attributes: Columns in a table (e.g., name, age).
• Fetch Requests: Queries to retrieve data from Core Data.

4. Create a Data Model

1. Open the .xcdatamodeld file (e.g., CoreDataDemo.xcdatamodeld).
2. Add a new Entity called Item:
   • Add two Attributes:
     • name (Type: String)
     • timestamp (Type: Date)
3. Save the file.

5. Define the Core Data Code

Here’s how to add and retrieve data.

1. Add Items to Core Data

swift
Copier le code
import SwiftUI
import CoreData

struct ContentView: View {
    @Environment(\.managedObjectContext) private var viewContext
    
    func addItem() {
        let newItem = Item(context: viewContext)
        newItem.name = "New Task"
        newItem.timestamp = Date()
        
        do {
            try viewContext.save()
        } catch {
            print("Error saving item: \(error.localizedDescription)")
        }
    }
    
    var body: some View {
        VStack {
            Button("Add Item") {
                addItem()
            }
        }
    }
}

• @Environment(\.managedObjectContext) gives access to the Core Data context.
• Item is the Entity created in the data model.
• viewContext.save() persists the changes.

2. Fetch Items from Core Data

To retrieve data:

swift
Copier le code
@FetchRequest(
    sortDescriptors: [NSSortDescriptor(keyPath: \Item.timestamp, ascending: true)],
    animation: .default)
private var items: FetchedResults<Item>

var body: some View {
    List {
        ForEach(items) { item in
            VStack(alignment: .leading) {
                Text(item.name ?? "Untitled")
                    .font(.headline)
                Text("Added on: \(item.timestamp ?? Date(), formatter: itemFormatter)")
            }
        }
    }
}

private let itemFormatter: DateFormatter = {
    let formatter = DateFormatter()
    formatter.dateStyle = .short
    formatter.timeStyle = .short
    return formatter
}()

• @FetchRequest retrieves all Item objects sorted by timestamp.
• ForEach displays the fetched items in a List.

3. Delete Items from Core Data

You can delete items using:

swift
Copier le code
ForEach(items) { item in
    HStack {
        Text(item.name ?? "Untitled")
        Spacer()
        Button("Delete") {
            viewContext.delete(item)
            try? viewContext.save()
        }
    }
}

Here:

• viewContext.delete(item) removes the item.
• Saving the context finalizes the deletion.

6. Final Structure of ContentView

Here’s the full ContentView combining Add, Fetch, and Delete operations:

swift
Copier le code
import SwiftUI
import CoreData

struct ContentView: View {
    @Environment(\.managedObjectContext) private var viewContext

    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Item.timestamp, ascending: true)],
        animation: .default)
    private var items: FetchedResults<Item>
    
    func addItem() {
        let newItem = Item(context: viewContext)
        newItem.name = "New Task"
        newItem.timestamp = Date()
        
        do {
            try viewContext.save()
        } catch {
            print("Error saving item: \(error.localizedDescription)")
        }
    }

    var body: some View {
        NavigationView {
            VStack {
                Button("Add Item") {
                    addItem()
                }
                List {
                    ForEach(items) { item in
                        VStack(alignment: .leading) {
                            Text(item.name ?? "Untitled")
                                .font(.headline)
                            Text("Added on: \(item.timestamp ?? Date(), formatter: itemFormatter)")
                        }
                    }
                    .onDelete(perform: deleteItems)
                }
                .navigationTitle("Core Data Demo")
                .toolbar {
                    EditButton()
                }
            }
        }
    }
    
    private func deleteItems(offsets: IndexSet) {
        withAnimation {
            offsets.map { items[$0] }.forEach(viewContext.delete)
            do {
                try viewContext.save()
            } catch {
                print("Error deleting item: \(error.localizedDescription)")
            }
        }
    }
}

private let itemFormatter: DateFormatter = {
    let formatter = DateFormatter()
    formatter.dateStyle = .short
    formatter.timeStyle = .short
    return formatter
}()

7. Run Your Project

• Build and run the app.
• Tap "Add Item" to insert data into Core Data.
• Swipe to delete rows or use the Edit button to remove items.

Key Concepts Recap

• Entities represent data models (tables).
• Attributes are properties (columns).
• Managed Object Context handles data operations.
• Use @FetchRequest to fetch and display data in a SwiftUI view.

Next Steps

• Add filters to fetch specific items.
• Learn about relationships between entities.
• Implement data persistence between app launches.