Cancellation handling in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a task has been cancelled.

Swift

if Task.isCancelled [1] {
    print("Task was cancelled")
}

Drag options to blanks, or click blank then click option'

Ais

B== false

C!=

D== true

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' false instead of '== true'

Using 'is' keyword incorrectly

Omitting the comparison operator

The property Task.isCancelled returns true if the task was cancelled. So we check if it is true.

2fill in blank

medium

Complete the code to throw a cancellation error inside an async task.

Swift

func fetchData() async throws {
    guard !Task.[1] else {
        throw CancellationError()
    }
    // continue fetching data
}

Drag options to blanks, or click blank then click option'

AisCancelled

Bcancelled

Ccancel

DisCanceling

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect property names like 'cancelled' or 'cancel'

Using 'isCanceling' which does not exist

The property Task.isCancelled is used to check if the current task has been cancelled.

3fill in blank

hard

Fix the error in the code to properly handle cancellation inside a Task.

Swift

Task {
    try await someAsyncFunction()
    if [1] {
        print("Cancelled")
    }
}

Drag options to blanks, or click blank then click option'

Aself.cancelled

BTask.cancelled

CTask.isCancelled

Dself.isCancelled

Attempts:

3 left

💡 Hint

Common Mistakes

Using instance properties instead of the static property

Using incorrect property names

Inside a Task, use Task.isCancelled to check if the task was cancelled.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that includes only non-cancelled tasks.

Swift

let activeTasks = [task: status for (task, status) in allTasks if task.[1] == false && !Task.[2]]

Drag options to blanks, or click blank then click option'

AisCancelled

Bcancelled

Dcanceling

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'cancelled' or 'canceling' which are not valid properties

Mixing instance and static properties incorrectly

Check each task's isCancelled property and also the static Task.isCancelled to filter out cancelled tasks.

5fill in blank

hard

Fill all three blanks to create a dictionary of task names and statuses for tasks that are not cancelled.

Swift

let filteredTasks = [[1]: [2] for ([3], status) in tasks if ![3].isCancelled]

Drag options to blanks, or click blank then click option'

Atask.name

Bstatus

Ctask

Dtasks

Attempts:

3 left

💡 Hint

Common Mistakes

Using the whole task as key instead of task.name

Using wrong variable names in the loop

The dictionary uses task.name as keys and status as values, iterating over task in tasks.

Practice

1. What is the main purpose of cancellation handling in Swift concurrency?

easy

A. To create new tasks continuously

B. To speed up all running tasks

C. To restart tasks automatically

D. To stop tasks that are no longer needed

Solution

1. Step 1: Understand cancellation handling concept

   Cancellation handling is used to stop tasks that are no longer needed to save resources.

2. Step 2: Compare options with concept

   Only To stop tasks that are no longer needed matches the purpose of stopping unnecessary tasks.

3. Final Answer:

   To stop tasks that are no longer needed -> Option D

4. Quick Check:

   Cancellation handling = stop unnecessary tasks [OK]

Hint: Cancellation means stopping tasks early to save resources [OK]

Common Mistakes:

• Thinking cancellation speeds up tasks
• Confusing cancellation with restarting tasks
• Assuming cancellation creates new tasks

2. Which of the following is the correct way to check for cancellation inside a Swift async task?

easy

A. if Task.cancelled() { return }

B. if Task.isCancelled { return }

C. if Task.checkCancel() { return }

D. if Task.isCancel { return }

Solution

1. Step 1: Recall correct API for cancellation check

   The correct property to check cancellation is Task.isCancelled.

2. Step 2: Verify syntax correctness

   if Task.isCancelled { return } uses Task.isCancelled correctly; others use invalid method or property names.

3. Final Answer:

   if Task.isCancelled { return } -> Option B

4. Quick Check:

   Use Task.isCancelled to check cancellation [OK]

Hint: Remember: Task.isCancelled is a property, not a method [OK]

Common Mistakes:

• Using incorrect method names like cancelled()
• Confusing property names with similar words
• Missing capitalization or spelling errors

3. What will be the output of the following Swift code snippet?

Task {
    for i in 1...3 {
        try Task.checkCancellation()
        print("Running step \(i)")
        if i == 2 {
            Task.current.cancel()
        }
    }
}

medium

A. Running step 1
Running step 2

B. Running step 1
Running step 2
Running step 3

C. Running step 1

D. No output due to immediate cancellation

Solution

1. Step 1: Understand Task.checkCancellation() behavior

   Task.checkCancellation() throws if the task is cancelled, stopping further execution.

2. Step 2: Analyze loop and cancellation timing

   Cancellation happens when i == 2, so steps 1 and 2 print, but step 3 is skipped due to cancellation.

3. Final Answer:

   Running step 1\nRunning step 2 -> Option A

4. Quick Check:

   Cancellation after step 2 stops step 3 [OK]

Hint: Cancellation stops loop after current iteration [OK]

Common Mistakes:

• Assuming all steps run despite cancellation
• Ignoring that checkCancellation throws on cancel
• Thinking cancellation happens before step 2

4. Identify the error in this Swift async task cancellation handling code:

Task {
    if Task.isCancelled {
        print("Cancelled")
    }
    try Task.checkCancellation()
    print("Running")
}

medium

A. Task.isCancelled check is redundant before checkCancellation()

B. Missing try keyword before Task.checkCancellation()

C. No error; code handles cancellation correctly

D. Task.isCancelled should be checked after checkCancellation()

Solution

1. Step 1: Understand difference between Task.isCancelled and checkCancellation()

   Task.checkCancellation() throws if cancelled, so it already handles cancellation detection.

2. Step 2: Analyze redundancy of Task.isCancelled check

   Checking Task.isCancelled before checkCancellation() is redundant because checkCancellation() will throw if cancelled.

3. Final Answer:

   Task.isCancelled check is redundant before checkCancellation() -> Option A

4. Quick Check:

   checkCancellation() alone suffices to detect cancellation [OK]

Hint: Use checkCancellation() to handle cancellation, no need for isCancelled first [OK]

Common Mistakes:

• Thinking isCancelled must come before checkCancellation()
• Missing try keyword (actually present here)
• Assuming no error when redundancy exists

5. You want to cancel a long-running Swift async task when a user taps a cancel button. Which approach correctly handles cancellation and cleans up resources?

func performTask() async {
    let task = Task {
        do {
            for i in 1...5 {
                try Task.checkCancellation()
                print("Processing \(i)")
                try await Task.sleep(nanoseconds: 1_000_000_000)
            }
        } catch {
            print("Task was cancelled")
        }
        print("Cleanup done")
    }
    // User taps cancel button
    task.cancel()
}

hard

A. Task.cancel() should be called inside the task, not outside

B. Cleanup code will not run after cancellation

C. This code correctly cancels the task and runs cleanup after cancellation

D. Task.checkCancellation() does not throw, so cancellation is ignored

Solution

1. Step 1: Analyze cancellation handling in the task

   Task.checkCancellation() throws when cancelled, caught by catch block which prints cancellation message.

2. Step 2: Verify cleanup code execution

   Cleanup code runs after catch block, ensuring resources are cleaned up even after cancellation.

3. Final Answer:

   This code correctly cancels the task and runs cleanup after cancellation -> Option C

4. Quick Check:

   Cancellation triggers catch and cleanup runs [OK]

Hint: Use try/catch with checkCancellation() to handle cancel and cleanup [OK]

Common Mistakes:

• Assuming cleanup won't run after cancellation
• Calling cancel() inside the task incorrectly
• Believing checkCancellation() does not throw