Stopping coroutines in Unity - Step-by-Step Execution

Concept Flow - Stopping coroutines

Start Coroutine

↓

Coroutine Running

↓

Check Stop Condition?

Yes→Stop Coroutine

No↓

Continue Coroutine

↓

Coroutine Ends Normally

This flow shows how a coroutine starts, runs, checks if it should stop, and either continues or stops.

Execution Sample

Unity

IEnumerator MyCoroutine() {
  while(true) {
    yield return null;
  }
}

Coroutine myCor = StartCoroutine(MyCoroutine());
StopCoroutine(myCor);

Starts a coroutine that runs indefinitely and then stops it.

Execution Table

Step	Action	Coroutine State	Result
1	StartCoroutine(MyCoroutine()) called	Running	Coroutine begins execution
2	Coroutine yields null (waits one frame)	Running	Coroutine pauses, will resume next frame
3	Coroutine resumes next frame	Running	Coroutine continues loop
4	StopCoroutine(myCor) called	Stopping	Coroutine is marked to stop
5	Coroutine stops before next yield	Stopped	Coroutine execution ends
6	Attempt to resume coroutine	Stopped	No action, coroutine already stopped

💡 Coroutine stops when StopCoroutine is called, preventing further execution.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
Coroutine State	Not started	Running	Stopping	Stopped

Key Moments - 2 Insights

Why does the coroutine stop immediately after StopCoroutine is called?

Because StopCoroutine marks the coroutine to stop, so it does not continue to the next yield or loop iteration as shown in steps 4 and 5 of the execution_table.

Can you stop a coroutine by calling StopCoroutine with the method name directly?

No, you must keep a reference to the started coroutine or use the IEnumerator instance; calling StopCoroutine with the method name alone may not stop the running coroutine properly.

Visual Quiz - 3 Questions

Look at the execution_table, what is the coroutine state after step 2?

A Running

B Stopped

C Not started

D Stopping

💡 Hint

Check the 'Coroutine State' column at step 2 in the execution_table.

At which step does the coroutine stop execution?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look for when the 'Coroutine State' changes to 'Stopped' in the execution_table.

If StopCoroutine was never called, what would happen at step 6?

A Coroutine would stop automatically

B Coroutine would continue running

C Coroutine would throw an error

D Coroutine would pause indefinitely

💡 Hint

Refer to the 'Coroutine State' progression in variable_tracker and execution_table.

Concept Snapshot

Stopping coroutines in Unity:
- Use StartCoroutine to begin.
- Coroutine runs until it yields or ends.
- Call StopCoroutine with the coroutine reference to stop it.
- Stopped coroutine does not resume.
- Keep reference to coroutine for reliable stopping.

Full Transcript

This visual trace shows how a coroutine in Unity starts running, yields control, and can be stopped by calling StopCoroutine. Initially, the coroutine is running and yields null to wait one frame. When StopCoroutine is called, the coroutine state changes to stopping and then stopped, preventing further execution. Variables track the coroutine state from not started to running, stopping, and finally stopped. Key moments clarify that StopCoroutine immediately halts the coroutine and that you need a reference to stop it properly. The quiz tests understanding of coroutine states at different steps and the effect of stopping or not stopping the coroutine.

Practice

1. What is the main purpose of stopping a coroutine in Unity?

easy

A. To halt an ongoing task or process before it finishes

B. To start a new coroutine automatically

C. To save the game state permanently

D. To increase the frame rate of the game

Solution

1. Step 1: Understand what coroutines do

   Coroutines run tasks over time, like waiting or animations.

2. Step 2: Purpose of stopping coroutines

   Stopping a coroutine means halting that ongoing task before it naturally ends.

3. Final Answer:

   To halt an ongoing task or process before it finishes -> Option A

4. Quick Check:

   Stopping coroutine = halting task [OK]

Hint: Stopping coroutines means stopping tasks in progress [OK]

Common Mistakes:

• Confusing stopping with starting coroutines
• Thinking stopping saves game data
• Assuming stopping affects frame rate

2. Which of the following is the correct syntax to stop a coroutine by its reference in Unity C#?

easy

A. EndCoroutine(coroutineReference);

B. StopCoroutineStart(coroutineReference);

C. Stop(coroutineReference);

D. StopCoroutine(coroutineReference);

Solution

1. Step 1: Recall Unity's coroutine stopping method

   Unity uses StopCoroutine() to stop coroutines by reference or name.

2. Step 2: Check method names

   Only StopCoroutine() matches Unity's API; others are invalid.

3. Final Answer:

   StopCoroutine(coroutineReference); -> Option D

4. Quick Check:

   Correct method name = StopCoroutine [OK]

Hint: Use StopCoroutine() exactly to stop by reference [OK]

Common Mistakes:

• Using incorrect method names like Stop() or EndCoroutine()
• Adding extra words like Start in method name
• Confusing with StartCoroutine syntax

3. What will be the output of the following Unity C# code snippet?

IEnumerator ExampleCoroutine() {
    Debug.Log("Start");
    yield return new WaitForSeconds(2);
    Debug.Log("End");
}

void Start() {
    Coroutine c = StartCoroutine(ExampleCoroutine());
    StopCoroutine(c);
    Debug.Log("Stopped");
}

medium

A. Start\nEnd\nStopped

B. Stopped

C. Start\nStopped

D. Start\nStopped\nEnd

Solution

1. Step 1: Analyze coroutine execution

   Coroutine logs "Start", waits 2 seconds, then logs "End".

2. Step 2: Effect of StopCoroutine

   StopCoroutine(c) stops it immediately after "Start" before "End" logs.

3. Final Answer:

   Start\nStopped -> Option C

4. Quick Check:

   StopCoroutine stops before "End" logs [OK]

Hint: StopCoroutine halts before delayed logs run [OK]

Common Mistakes:

• Assuming 'End' logs after stopping
• Ignoring immediate stop effect
• Thinking 'Stopped' logs inside coroutine

4. Identify the error in this Unity C# code snippet that tries to stop a coroutine:

IEnumerator MyCoroutine() {
    yield return new WaitForSeconds(1);
    Debug.Log("Done");
}

void Start() {
    StartCoroutine(MyCoroutine());
    StopCoroutine("MyCoroutine");
}

medium

A. StopCoroutine("MyCoroutine") requires the coroutine to be started by string name

B. StopCoroutine only works with IEnumerator variables

C. Coroutine must be stopped inside the coroutine itself

D. StopCoroutine cannot stop coroutines started without storing reference

Solution

1. Step 1: Understand how StopCoroutine(string) works

   StopCoroutine with string stops coroutines started by string name.

2. Step 2: Check how coroutine is started

   Coroutine started by method call, not by string name, so StopCoroutine("MyCoroutine") fails.

3. Final Answer:

   StopCoroutine("MyCoroutine") requires the coroutine to be started by string name -> Option A

4. Quick Check:

   StopCoroutine(string) needs string start [OK]

Hint: StopCoroutine(string) only stops coroutines started by string [OK]

Common Mistakes:

• Stopping coroutine by string without starting by string
• Thinking StopCoroutine must be inside coroutine
• Assuming StopCoroutine works with IEnumerator variables

5. You have multiple coroutines running in a Unity script. Which method stops all coroutines at once, and what is a common use case for this?

hard

A. StopCoroutineAll(); used to pause the game

B. StopAllCoroutines(); used to reset game state quickly

C. StopAll(); used to save memory

D. StopCoroutine(); used to stop one coroutine

Solution

1. Step 1: Identify method to stop all coroutines

   Unity provides StopAllCoroutines() to stop every coroutine running on that script.

2. Step 2: Understand common use case

   Stopping all coroutines helps reset game state or stop ongoing processes quickly.

3. Final Answer:

   StopAllCoroutines(); used to reset game state quickly -> Option B

4. Quick Check:

   StopAllCoroutines = stop all tasks fast [OK]

Hint: Use StopAllCoroutines() to stop every coroutine fast [OK]

Common Mistakes:

• Using wrong method names like StopAll() or StopCoroutineAll()
• Confusing stopping all with stopping one coroutine
• Misunderstanding use cases for stopping all coroutines