Coroutine chaining in Unity - Step-by-Step Execution

Concept Flow - Coroutine chaining

Start First Coroutine

↓

Yield Until First Coroutine Completes

↓

Start Second Coroutine

↓

Yield Until Second Coroutine Completes

↓

Done

Start one coroutine, wait for it to finish, then start the next coroutine, chaining them in sequence.

Execution Sample

Unity

IEnumerator First() {
  Debug.Log("First start");
  yield return new WaitForSeconds(1);
  Debug.Log("First end");
}

IEnumerator Second() {
  Debug.Log("Second start");
  yield return new WaitForSeconds(1);
  Debug.Log("Second end");
}

IEnumerator Chain() {
  yield return StartCoroutine(First());
  yield return StartCoroutine(Second());
  Debug.Log("Chain complete");
}

Runs First coroutine, waits 1 second, then runs Second coroutine, waits 1 second, then prints completion.

Execution Table

Step	Action	Coroutine Running	Yield/Wait	Output
1	Start Chain coroutine	Chain	Start First coroutine	No output
2	Start First coroutine	First	WaitForSeconds(1)	Print: First start
3	Wait 1 second	First	Waiting	No output
4	First coroutine resumes	First	Complete	Print: First end
5	Return to Chain coroutine	Chain	Start Second coroutine	No output
6	Start Second coroutine	Second	WaitForSeconds(1)	Print: Second start
7	Wait 1 second	Second	Waiting	No output
8	Second coroutine resumes	Second	Complete	Print: Second end
9	Return to Chain coroutine	Chain	Complete	Print: Chain complete
10	Chain coroutine ends	None	None	No output

💡 Chain coroutine finishes after Second coroutine completes and prints final message.

Variable Tracker

Coroutine	Start	After Step 2	After Step 4	After Step 6	After Step 8	Final
Chain	Running	Waiting for First	Waiting for Second	Waiting for Second	Completed	Completed
First	Not started	Running	Completed	Completed	Completed	Completed
Second	Not started	Not started	Not started	Running	Completed	Completed

Key Moments - 3 Insights

Why does the Chain coroutine wait at 'yield return StartCoroutine(First())'?

Because 'yield return StartCoroutine(First())' pauses Chain until First finishes, as shown in execution_table rows 2 to 4.

What happens if we don't yield return the StartCoroutine call?

Chain would not wait for the coroutine to finish and would start the next immediately, losing the chaining effect (not shown in this trace).

Why do we see 'Chain complete' only after Second coroutine ends?

Because Chain waits for Second to finish before continuing, as shown in execution_table rows 7 to 9.

Visual Quiz - 3 Questions

Look at the execution_table, what coroutine is running at Step 6?

A First coroutine

B Second coroutine

C Chain coroutine

D No coroutine running

💡 Hint

Check the 'Coroutine Running' column at Step 6 in the execution_table.

At which step does the Chain coroutine resume after First coroutine completes?

A Step 3

B Step 4

C Step 5

D Step 7

💡 Hint

Look for when Chain starts Second coroutine after First ends in the execution_table.

If we remove 'yield return' before StartCoroutine(First()), what changes in variable_tracker?

A Second coroutine would start before First ends

B Chain coroutine would be 'Running' throughout without waiting

C First coroutine would never start

D Chain coroutine would end immediately

💡 Hint

Think about how 'yield return' controls waiting shown in variable_tracker and execution_table.

Concept Snapshot

Coroutine chaining in Unity:
Use 'yield return StartCoroutine(OtherCoroutine())' to run one coroutine after another.
The calling coroutine pauses until the called coroutine finishes.
This creates a sequence of asynchronous steps.
Without 'yield return', coroutines run concurrently, not sequentially.

Full Transcript

This example shows how coroutine chaining works in Unity. The Chain coroutine starts and yields to First coroutine. First coroutine runs, waits 1 second, then ends. Chain waits until First finishes before starting Second coroutine. Second coroutine runs, waits 1 second, then ends. Finally, Chain prints 'Chain complete' and ends. The execution table tracks each step, showing which coroutine runs and what output is printed. Variable tracker shows coroutine states changing from running to waiting to completed. Key moments clarify why 'yield return' is needed to pause and wait for coroutines. The visual quiz tests understanding of coroutine states and chaining behavior.

Practice

1. What does yield return StartCoroutine() do in Unity coroutine chaining?

easy

A. It immediately stops all coroutines running in the script.

B. It waits for the called coroutine to finish before continuing.

C. It starts a coroutine but does not wait for it to finish.

D. It pauses the game until the coroutine completes.

Solution

1. Step 1: Understand coroutine chaining

   Coroutine chaining means running one coroutine after another finishes.

2. Step 2: Role of yield return StartCoroutine()

   This statement pauses the current coroutine until the called coroutine completes.

3. Final Answer:

   It waits for the called coroutine to finish before continuing. -> Option B

4. Quick Check:

   Yield return StartCoroutine waits for completion [OK]

Hint: Remember: yield return waits for coroutine to finish [OK]

Common Mistakes:

• Thinking it stops all coroutines
• Assuming it doesn't wait for completion
• Confusing it with pausing the entire game

2. Which of the following is the correct syntax to chain two coroutines First() and Second() in Unity?

easy

A. yield return First; yield return Second;

B. StartCoroutine(First()); StartCoroutine(Second());

C. StartCoroutine(First()); yield return Second();

D. yield return StartCoroutine(First()); yield return StartCoroutine(Second());

Solution

1. Step 1: Identify correct coroutine chaining syntax

   To chain coroutines, you must yield return StartCoroutine to wait for each to finish.

2. Step 2: Analyze options

   yield return StartCoroutine(First()); yield return StartCoroutine(Second()); uses yield return StartCoroutine for both, correctly chaining them.

3. Final Answer:

   yield return StartCoroutine(First()); yield return StartCoroutine(Second()); -> Option D

4. Quick Check:

   Correct chaining uses yield return StartCoroutine [OK]

Hint: Use yield return StartCoroutine to chain coroutines [OK]

Common Mistakes:

• Calling coroutines without yield return
• Using yield return without StartCoroutine
• Starting coroutines without waiting

3. What will be the output order when running this Unity coroutine code?

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

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

IEnumerator Chain() {
    yield return StartCoroutine(First());
    yield return StartCoroutine(Second());
    Debug.Log("Chain Complete");
}

medium

A. ["Start First", "End First", "Start Second", "End Second", "Chain Complete"]

B. ["Start First", "Start Second", "End First", "End Second", "Chain Complete"]

C. ["Start First", "End First", "Chain Complete", "Start Second", "End Second"]

D. ["Start First", "Start Second", "Chain Complete", "End First", "End Second"]

Solution

1. Step 1: Understand coroutine chaining order

   Chain waits for First to finish before starting Second, then logs completion.

2. Step 2: Trace output sequence

   First logs start, waits 1s, logs end; then Second logs start, waits 1s, logs end; finally Chain logs complete.

3. Final Answer:

   ["Start First", "End First", "Start Second", "End Second", "Chain Complete"] -> Option A

4. Quick Check:

   Chained coroutines run sequentially [OK]

Hint: Chained coroutines run fully one after another [OK]

Common Mistakes:

• Assuming coroutines run in parallel
• Expecting logs to mix order
• Missing that Chain logs last

4. Identify the error in this coroutine chaining code snippet:

IEnumerator Chain() {
    StartCoroutine(First());
    yield return StartCoroutine(Second());
    Debug.Log("Done");
}

medium

A. Debug.Log("Done") is called before any coroutine.

B. Second coroutine is not started correctly.

C. First coroutine is started but not waited for before Second starts.

D. Chain coroutine should not use yield return.

Solution

1. Step 1: Check how coroutines are started and waited

   First coroutine is started without yield return, so Chain does not wait for it.

2. Step 2: Understand effect on chaining

   Second coroutine waits correctly, but First runs in parallel, breaking chaining order.

3. Final Answer:

   First coroutine is started but not waited for before Second starts. -> Option C

4. Quick Check:

   StartCoroutine without yield return doesn't wait [OK]

Hint: Always yield return StartCoroutine to wait [OK]

Common Mistakes:

• Starting coroutine without yield return
• Assuming StartCoroutine waits automatically
• Misunderstanding coroutine execution order

5. You want to chain three coroutines LoadData(), ProcessData(), and DisplayData() so each starts only after the previous finishes. Which code snippet correctly implements this chaining?

hard

A. yield return StartCoroutine(LoadData());
yield return StartCoroutine(ProcessData());
yield return StartCoroutine(DisplayData());

B. StartCoroutine(LoadData());
StartCoroutine(ProcessData());
StartCoroutine(DisplayData());

C. yield return LoadData;
yield return ProcessData;
yield return DisplayData;

D. StartCoroutine(LoadData());
yield return ProcessData();
yield return DisplayData();

Solution

1. Step 1: Understand chaining requirement

   Each coroutine must finish before the next starts, so we must wait for each.

2. Step 2: Analyze correct chaining syntax

   Using yield return StartCoroutine ensures waiting for each coroutine to complete before continuing.

3. Final Answer:

   yield return StartCoroutine(LoadData()); yield return StartCoroutine(ProcessData()); yield return StartCoroutine(DisplayData()); -> Option A

4. Quick Check:

   Yield return StartCoroutine chains coroutines sequentially [OK]

Hint: Chain with yield return StartCoroutine for sequential execution [OK]

Common Mistakes:

• Starting all coroutines without waiting
• Yield returning coroutine call without StartCoroutine
• Mixing yield return and StartCoroutine incorrectly