SwiftData setup (modern persistence) in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the role of the @Model attribute in SwiftData?

In SwiftData, you mark your data model classes with @Model. What does this attribute do?

A It disables persistence for the class, making it transient only.

B It marks the class as a UI component to be displayed on screen.

C It tells SwiftData to manage the class as a persistent data model with automatic storage support.

D It converts the class into a network data transfer object.

💡 Hint

Think about what you want SwiftData to do with your data classes.

The @Model attribute tells SwiftData to treat the class as a persistent model. This enables automatic saving, fetching, and syncing of data.

❓ ui_behavior

intermediate

What happens if you forget to inject the ModelContext into your SwiftUI view?

You have a SwiftUI view that needs to save data using SwiftData, but you forget to add @Environment(\.modelContext). What will happen when you try to save?

A The app will crash at runtime with a missing environment key error.

B The data will save normally without any issues.

C The data will save but only locally, not persisted.

D The compiler will show an error and prevent building.

💡 Hint

Think about how SwiftUI provides the context to views.

If you don't inject modelContext, the view cannot access the persistence context. This causes a runtime crash because the environment key is missing.

❓ lifecycle

advanced

When is the SwiftData container initialized in a typical SwiftUI app?

In a SwiftUI app using SwiftData, when is the ModelContainer typically created and injected?

A Automatically by the system without any code needed.

B In the app's main struct, during initialization, before the first view appears.

C Inside each view's <code>onAppear</code> method individually.

D Only after the user logs in, triggered by a button action.

💡 Hint

Consider where you set up global app state in SwiftUI.

The ModelContainer is created once in the app's main struct (e.g., in @main) and injected into the environment for all views to access.

❓ navigation

advanced

How do you pass a managed SwiftData model object between views?

You want to navigate from a list view to a detail view showing a SwiftData model object. How should you pass the object?

A Create a new instance of the model object in the detail view.

B Pass only the object's ID and fetch it again in the detail view.

C Store the object in UserDefaults and read it in the detail view.

D Pass the model object directly as a parameter to the detail view initializer.

💡 Hint

Think about how SwiftData manages object identity and sharing.

Passing the model object directly keeps the same managed instance, allowing edits and updates to sync automatically.

🔧 Debug

expert

Why does this SwiftData save operation fail silently?

Consider this code snippet inside a SwiftUI view:

func saveItem() {
  let newItem = Item(name: "Test")
  modelContext.insert(newItem)
  // Missing save call here
}

Why does the new item not persist after app restart?

A Because <code>modelContext.save()</code> was not called to commit changes.

B Because the <code>modelContext</code> was not injected into the view.

C Because the <code>Item</code> model is missing the <code>@Model</code> attribute.

D Because the item name "Test" is invalid and rejected by SwiftData.

💡 Hint

Think about what final step is needed to persist changes.

In SwiftData, inserting an object adds it to the context, but you must call modelContext.save() to write changes to disk.

Practice

1. What is the purpose of marking a class with @Model in SwiftData?

easy

A. It disables saving data for that class.

B. It makes the class visible only to the current view.

C. It tells SwiftData to manage and save instances of that class automatically.

D. It converts the class into a SwiftUI view.

Solution

1. Step 1: Understand the role of @Model

   The @Model attribute marks a class as a data model for SwiftData to manage persistence.

2. Step 2: Recognize automatic data management

   SwiftData automatically saves and tracks changes for classes marked with @Model.

3. Final Answer:

   It tells SwiftData to manage and save instances of that class automatically. -> Option C

4. Quick Check:

   @Model means automatic data management [OK]

Hint: Remember: @Model means SwiftData saves your data class [OK]

Common Mistakes:

• Thinking @Model creates a UI component
• Assuming @Model disables saving
• Confusing @Model with view modifiers

2. Which of the following is the correct way to set up a SwiftData model container in your app's main entry point?

easy

A. let container = ModelContainer(for: MyModel.self)

B. let container = .modelContainer(for: MyModel.self)

C. let container = ModelContainer(for: [MyModel].self)

D. let container = .modelContainer(for: [MyModel].self)

Solution

1. Step 1: Recall the correct syntax for model container setup

   SwiftData uses ModelContainer(for: MyModel.self) to create a container for a single model type.

2. Step 2: Identify the correct option

   let container = ModelContainer(for: MyModel.self) uses the correct constructor syntax.

3. Final Answer:

   let container = ModelContainer(for: MyModel.self) -> Option A

4. Quick Check:

   Model container setup uses ModelContainer(for: Type.self) [OK]

Hint: ModelContainer(for: MyModel.self) [OK]

Common Mistakes:

• Using [MyModel].self array syntax incorrectly
• Using .modelContainer() which is a view modifier
• Forgetting .self after the type

3. Given this SwiftUI view using SwiftData:

struct ContentView: View {
  @Environment(\.modelContext) private var context
  @Query var items: [Item]

  var body: some View {
    List(items) { item in
      Text(item.name)
    }
  }
}

What will happen if you add a new Item to context?

medium

A. The new item will be saved but not displayed in the list.

B. The list will not update until the app restarts.

C. The app will crash because @Query cannot detect changes.

D. The list will automatically update to show the new item.

Solution

1. Step 1: Understand @Query and @Environment(\.modelContext)

   @Query fetches data from the model container and updates the view automatically when data changes.

2. Step 2: Recognize automatic UI updates

   Adding a new Item to context triggers the @Query to refresh, updating the list.

3. Final Answer:

   The list will automatically update to show the new item. -> Option D

4. Quick Check:

   @Query updates UI on data change [OK]

Hint: @Query auto-refreshes UI when data changes [OK]

Common Mistakes:

• Thinking UI updates only on app restart
• Believing @Query is static data
• Assuming app crashes on data change

4. You wrote this code but your app crashes at runtime:

@Model
class Task {
  var title: String
  init(title: String) {
    self.title = title
  }
}

What is the likely cause of the crash?

medium

A. The class is missing a default initializer for SwiftData.

B. You must mark the class as final when using @Model.

C. The property title must be optional.

D. You cannot use classes with @Model, only structs.

Solution

1. Step 1: Check SwiftData model requirements

   SwiftData requires model classes to have a default initializer or all properties to have default values.

2. Step 2: Identify missing default initializer

   The class has a custom initializer but no default one, causing runtime issues.

3. Final Answer:

   The class is missing a default initializer for SwiftData. -> Option A

4. Quick Check:

   SwiftData models need default initializers [OK]

Hint: Ensure @Model classes have default initializers [OK]

Common Mistakes:

• Thinking @Model requires final keyword
• Making properties optional unnecessarily
• Believing only structs can be @Model

5. You want to create a SwiftData model for a Book with a title and optional author. You also want to fetch all books with a non-empty author in a SwiftUI view. Which code snippet correctly defines the model and query?

hard

A. @Model
class Book {
var title: String
var author: String
init() { title = ""; author = "" }
}
@Query(filter: #Predicate { $0.author != "" }) var books: [Book]

B. @Model
class Book {
var title: String = ""
var author: String? = nil
}
@Query(filter: #Predicate { $0.author != nil && !$0.author!.isEmpty }) var books: [Book]

C. @Model
class Book {
var title: String
var author: String?
}
@Query(filter: #Predicate { $0.author != nil }) var books: [Book]

D. @Model
class Book {
var title: String = ""
var author: String = ""
}
@Query(filter: #Predicate { $0.author.isEmpty }) var books: [Book]

Solution

1. Step 1: Define model with optional author and default values

   @Model
   class Book {
     var title: String = ""
     var author: String? = nil
   }

   @Query(filter: #Predicate { $0.author != nil && !$0.author!.isEmpty }) var books: [Book]

   correctly defines author as optional with a default nil and title with a default empty string.

2. Step 2: Use a filter predicate to fetch books with non-empty author

   The filter checks author != nil and that author is not empty, matching the requirement.

3. Final Answer:

   Correctly defines the model and query for non-empty authors. -> Option B

4. Quick Check:

   Optional author + filter for non-empty =

   @Model
   class Book {
     var title: String = ""
     var author: String? = nil
   }

   @Query(filter: #Predicate { $0.author != nil && !$0.author!.isEmpty }) var books: [Book]

   [OK]

Hint: Use optional property and filter for non-empty string [OK]

Common Mistakes:

• Forgetting to make author optional
• Using empty string author without optional
• Incorrect filter logic for non-empty strings