Coroutine chaining in Unity

Introduction

Coroutine chaining helps you run tasks one after another without freezing your game. It makes your game smooth and easy to follow.

You want to play one animation, then wait, then play another animation.

You need to load game data step-by-step without stopping the game.

You want to show messages one after another with delays.

You want to move a character, then wait, then make it jump.

You want to perform multiple timed actions in order.

Syntax

Unity

using System.Collections;
using UnityEngine;

public class CoroutineChainExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(FirstCoroutine());
    }

    IEnumerator FirstCoroutine()
    {
        // Do something
        yield return new WaitForSeconds(1f);

        // Start next coroutine and wait for it to finish
        yield return StartCoroutine(SecondCoroutine());

        // Continue after second coroutine finishes
        Debug.Log("All coroutines finished.");
    }

    IEnumerator SecondCoroutine()
    {
        // Do something else
        yield return new WaitForSeconds(2f);
    }
}

You use yield return StartCoroutine(OtherCoroutine()) to wait for another coroutine to finish.

Coroutines run over multiple frames without freezing the game.

Examples

This coroutine does nothing and ends immediately.

Unity

IEnumerator EmptyCoroutine()
{
    // No yield, runs instantly
    yield break;
}

This coroutine runs two steps with a frame delay.

Unity

IEnumerator SingleStepCoroutine()
{
    Debug.Log("Step 1");
    yield return null; // Wait one frame
    Debug.Log("Step 2");
}

This shows chaining two coroutines that wait and print messages in order.

Unity

IEnumerator ChainExample()
{
    Debug.Log("Start first");
    yield return StartCoroutine(WaitAndPrint(1f, "First done"));
    Debug.Log("Start second");
    yield return StartCoroutine(WaitAndPrint(2f, "Second done"));
    Debug.Log("Chain complete");
}

IEnumerator WaitAndPrint(float waitTime, string message)
{
    yield return new WaitForSeconds(waitTime);
    Debug.Log(message);
}

Sample Program

This program starts a coroutine chain where the first task waits 1 second, then starts the second task which waits 2 seconds. Messages show the order clearly.

Unity

using System.Collections;
using UnityEngine;

public class CoroutineChainDemo : MonoBehaviour
{
    void Start()
    {
        Debug.Log("Starting coroutine chain...");
        StartCoroutine(FirstTask());
    }

    IEnumerator FirstTask()
    {
        Debug.Log("First task started");
        yield return new WaitForSeconds(1f);
        Debug.Log("First task finished, starting second task");

        yield return StartCoroutine(SecondTask());

        Debug.Log("All tasks completed");
    }

    IEnumerator SecondTask()
    {
        Debug.Log("Second task started");
        yield return new WaitForSeconds(2f);
        Debug.Log("Second task finished");
    }
}

Important Notes

Time complexity depends on the wait times and tasks inside coroutines, but chaining itself is simple and fast.

Space complexity is low; coroutines use little memory while waiting.

Common mistake: forgetting to yield return the chained coroutine, which causes tasks to run at the same time instead of in order.

Use coroutine chaining when you want tasks to happen one after another without blocking the game. Use parallel coroutines if tasks can run together.

Summary

Coroutine chaining lets you run tasks one after another smoothly.

Use yield return StartCoroutine() to wait for the next task.

This helps keep your game responsive and organized.

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