Coroutine basics (IEnumerator) in Unity - Step-by-Step Execution

Concept Flow - Coroutine basics (IEnumerator)

Start Coroutine

↓

Execute IEnumerator Step

↓

Yield return Wait or null?

↓

Pause Execution

↓

Check if more steps

Yes↓

Execute Next IEnumerator Step

No↓

Coroutine Ends

The coroutine starts and runs each step of the IEnumerator. When it hits a yield, it pauses and resumes later until all steps finish.

Execution Sample

Unity

IEnumerator ExampleCoroutine() {
  Debug.Log("Start");
  yield return null;
  Debug.Log("After one frame");
  yield return new WaitForSeconds(1);
  Debug.Log("After 1 second");
}

This coroutine logs messages, waits one frame, then waits one second before finishing.

Execution Table

Step	Action	Yield Returned	Coroutine Paused?	Output
1	Start coroutine, run first Debug.Log	null	Yes (wait one frame)	Start
2	Resume after one frame, run second Debug.Log	WaitForSeconds(1)	Yes (wait 1 second)	After one frame
3	Resume after 1 second, run third Debug.Log	none	No (coroutine ends)	After 1 second

💡 Coroutine ends after all steps run and no more yield statements.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3
Coroutine State	Not started	Paused (yield null)	Paused (yield WaitForSeconds)	Finished

Key Moments - 3 Insights

Why does the coroutine pause after 'yield return null'?

Because 'yield return null' tells Unity to pause the coroutine and resume it in the next frame, as shown in execution_table step 1.

What happens when the coroutine yields 'WaitForSeconds(1)'?

The coroutine pauses for 1 second before continuing, as seen in execution_table step 2 where it waits before running the next Debug.Log.

When does the coroutine actually end?

It ends after the last Debug.Log runs and there is no more yield, shown in execution_table step 3 where 'Coroutine Paused?' is No.

Visual Quiz - 3 Questions

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

A Finished

B Paused waiting for 1 second

C Running without pause

D Paused waiting for next frame

💡 Hint

Check 'Coroutine Paused?' and 'Yield Returned' columns in execution_table row 2.

At which step does the coroutine stop pausing and finish?

A Step 3

B Step 2

C Step 1

D It never finishes

💡 Hint

Look at 'Coroutine Paused?' column in execution_table to find when it says 'No'.

If we remove 'yield return null', what changes in the execution_table?

A Coroutine pauses for one frame at step 1

B Coroutine pauses for 1 second at step 1

C First two Debug.Logs run immediately, then pause for 1 second

D Coroutine never starts

💡 Hint

Refer to how 'yield return null' causes pause in execution_table step 1.

Concept Snapshot

Coroutine basics with IEnumerator in Unity:
- Coroutine runs code step-by-step.
- 'yield return null' pauses until next frame.
- 'yield return WaitForSeconds(x)' pauses for x seconds.
- Coroutine resumes after each yield until done.
- Use Debug.Log to see execution order.

Full Transcript

This visual trace shows how a Unity coroutine using IEnumerator runs step-by-step. The coroutine starts and runs the first Debug.Log, then pauses because of 'yield return null' until the next frame. After resuming, it logs again and pauses for 1 second due to 'yield return new WaitForSeconds(1)'. Finally, it logs the last message and ends because there are no more yield statements. Variables track the coroutine state as Not started, Paused, and Finished. Key moments clarify why the coroutine pauses and when it ends. The quiz tests understanding of pause points and coroutine flow.

Practice

1. What is the main purpose of using a Coroutine in Unity?

easy

A. To handle user input events only

B. To create new game objects instantly

C. To pause and resume code execution over time without freezing the game

D. To permanently stop the game

Solution

1. Step 1: Understand Coroutine behavior

   Coroutines allow code to pause and continue later, useful for timed actions.

2. Step 2: Compare options

   Only To pause and resume code execution over time without freezing the game describes pausing and resuming code smoothly without freezing the game.

3. Final Answer:

   To pause and resume code execution over time without freezing the game -> Option C

4. Quick Check:

   Coroutine = pause and resume code [OK]

Hint: Coroutines pause code without freezing game [OK]

Common Mistakes:

• Thinking coroutines create objects
• Confusing coroutines with event handlers
• Believing coroutines stop the game

2. Which of the following is the correct way to declare a coroutine method in Unity?

easy

A. public IEnumerator MyCoroutine() { yield return null; }

B. public string MyCoroutine() { yield return null; }

C. public int MyCoroutine() { yield return null; }

D. public void MyCoroutine() { yield return null; }

Solution

1. Step 1: Recall coroutine method signature

   Coroutine methods must return IEnumerator to support yield return.

2. Step 2: Check each option's return type

   Only public IEnumerator MyCoroutine() { yield return null; } returns IEnumerator and uses yield return correctly.

3. Final Answer:

   public IEnumerator MyCoroutine() { yield return null; } -> Option A

4. Quick Check:

   Coroutine method returns IEnumerator [OK]

Hint: Coroutine methods always return IEnumerator [OK]

Common Mistakes:

• Using void as return type
• Returning int or string instead of IEnumerator
• Forgetting yield return inside coroutine

3. What will be the output of this Unity coroutine code snippet?

IEnumerator PrintNumbers() {
    for (int i = 1; i <= 3; i++) {
        Debug.Log(i);
        yield return new WaitForSeconds(1);
    }
}

StartCoroutine(PrintNumbers());

medium

A. Prints 1, 2, 3 immediately without delay

B. Prints 1, then waits 1 second, prints 2, waits 1 second, prints 3

C. Prints 3 three times with 1 second delay

D. No output because coroutine is not started properly

Solution

1. Step 1: Understand the for loop with yield

   The loop prints i, then waits 1 second before next iteration.

2. Step 2: Trace output timing

   It prints 1, waits 1 second, prints 2, waits 1 second, then prints 3.

3. Final Answer:

   Prints 1, then waits 1 second, prints 2, waits 1 second, prints 3 -> Option B

4. Quick Check:

   yield return WaitForSeconds delays output [OK]

Hint: yield return pauses loop iteration [OK]

Common Mistakes:

• Assuming all prints happen instantly
• Thinking it prints 3 repeatedly
• Forgetting to start coroutine with StartCoroutine

4. Identify the error in this coroutine code:

IEnumerator Example() {
    Debug.Log("Start");
    yield WaitForSeconds(2);
    Debug.Log("End");
}

StartCoroutine(Example());

medium

A. Missing 'return' keyword before WaitForSeconds

B. Coroutine method should return void

C. StartCoroutine cannot be used with IEnumerator

D. Debug.Log cannot be used inside coroutines

Solution

1. Step 1: Check yield statement syntax

   Correct syntax requires 'yield return' before WaitForSeconds.

2. Step 2: Verify other parts

   Coroutine returns IEnumerator, StartCoroutine usage is correct, Debug.Log works inside coroutines.

3. Final Answer:

   Missing 'return' keyword before WaitForSeconds -> Option A

4. Quick Check:

   Use 'yield return' with WaitForSeconds [OK]

Hint: Always write 'yield return' before waiting [OK]

Common Mistakes:

• Writing 'yield' without 'return'
• Using void return type for coroutine
• Thinking StartCoroutine can't start IEnumerator

5. You want to create a coroutine that fades out a UI element over 3 seconds smoothly. Which approach correctly uses IEnumerator and yield return to achieve this?

hard

A. Change opacity once, then yield return new WaitForSeconds(3) without gradual change

B. Call StartCoroutine inside Update() every frame without stopping

C. Use a for loop without yield return to change opacity instantly

D. Use a loop that changes opacity gradually, yielding null each frame until 3 seconds pass

Solution

1. Step 1: Understand smooth fading with coroutine

   Smooth fade requires gradual opacity change over time with frame-by-frame updates.

2. Step 2: Analyze options for gradual change and yielding

   Use a loop that changes opacity gradually, yielding null each frame until 3 seconds pass uses a loop with yield return null to wait one frame each iteration, allowing smooth fade over 3 seconds.

3. Final Answer:

   Use a loop that changes opacity gradually, yielding null each frame until 3 seconds pass -> Option D

4. Quick Check:

   Gradual change + yield return null = smooth fade [OK]

Hint: Yield null each frame for smooth animation [OK]

Common Mistakes:

• Waiting full time without gradual change
• Not yielding inside loop causing freeze
• Starting coroutine repeatedly without stop