WaitForSeconds and WaitForEndOfFrame in Unity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of WaitForSeconds in Coroutine

What will be the output of this Unity C# coroutine code snippet?

Unity

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

A Start immediately, then after 1 second print 'After 1 second'

B Print both messages immediately without delay

C Print only 'Start' and never print 'After 1 second'

D Print 'After 1 second' first, then 'Start'

💡 Hint

Think about how WaitForSeconds pauses the coroutine.

The coroutine prints 'Start' immediately, then pauses for 1 second due to WaitForSeconds(1f), and finally prints 'After 1 second'.

❓ Predict Output

intermediate

When does WaitForEndOfFrame execute?

Consider this coroutine snippet. When will the message 'End of frame reached' be printed?

Unity

IEnumerator FrameCoroutine() {
    Debug.Log("Before waiting");
    yield return new WaitForEndOfFrame();
    Debug.Log("End of frame reached");
}

A After 1 second delay

B Immediately without waiting

C Before rendering starts for the frame

D After all rendering for the current frame is done

💡 Hint

Think about the frame lifecycle in Unity and when WaitForEndOfFrame resumes.

WaitForEndOfFrame waits until the frame finishes rendering, then resumes the coroutine, so the message prints after rendering.

🔧 Debug

advanced

Why does this coroutine never print the second message?

Look at this coroutine code. Why does it never print 'Second message'?

Unity

IEnumerator TestCoroutine() {
    Debug.Log("First message");
    yield return new WaitForSeconds(-1f);
    Debug.Log("Second message");
}

A It causes a compile error and never runs

B WaitForSeconds with negative time causes the coroutine to stop and never resume

C Negative time is treated as zero, so both messages print immediately

D The coroutine throws an exception and stops

💡 Hint

Check how WaitForSeconds handles negative values.

Using a negative time in WaitForSeconds causes the coroutine to wait indefinitely and never resume, so the second message never prints.

🧠 Conceptual

advanced

Difference between WaitForSeconds and WaitForEndOfFrame

Which statement correctly describes the difference between WaitForSeconds and WaitForEndOfFrame in Unity coroutines?

A <code>WaitForSeconds</code> pauses for a set time; <code>WaitForEndOfFrame</code> waits until the current frame finishes rendering

B Both wait for a fixed time but differ in precision

C <code>WaitForSeconds</code> waits until the frame ends; <code>WaitForEndOfFrame</code> pauses for a set time

D Both wait until the next frame starts

💡 Hint

Think about timing: fixed seconds vs frame lifecycle.

WaitForSeconds delays the coroutine by a specified number of seconds. WaitForEndOfFrame waits until the frame rendering completes before continuing.

❓ Predict Output

expert

Number of times a message prints in this coroutine

Given this coroutine, how many times will 'Frame ended' print after starting it once?

Unity

IEnumerator LoopCoroutine() {
    while (true) {
        yield return new WaitForEndOfFrame();
        Debug.Log("Frame ended");
    }
}

A It prints only once and then stops

B It prints once per frame indefinitely until stopped

C It never prints because of an infinite loop error

D It prints twice per frame

💡 Hint

Consider what an infinite loop with WaitForEndOfFrame means in a coroutine.

The coroutine waits until the end of each frame, then prints the message, and repeats forever, printing once per frame.

Practice

1. What does WaitForSeconds do in a Unity coroutine?

easy

A. Pauses the coroutine for a specified amount of time.

B. Waits until the end of the current frame before continuing.

C. Stops the coroutine permanently.

D. Immediately resumes the coroutine without delay.

Solution

1. Step 1: Understand the purpose of WaitForSeconds

   WaitForSeconds pauses the coroutine for a set number of seconds before continuing.

2. Step 2: Compare with other options

   WaitForEndOfFrame waits for the frame to finish, not a time delay. The others are incorrect behaviors.

3. Final Answer:

   Pauses the coroutine for a specified amount of time. -> Option A

4. Quick Check:

   WaitForSeconds = pause time [OK]

Hint: WaitForSeconds pauses by seconds, not frames or immediate resume [OK]

Common Mistakes:

• Confusing WaitForSeconds with WaitForEndOfFrame
• Thinking it stops coroutine permanently
• Assuming it resumes immediately

2. Which of the following is the correct syntax to wait for the end of the current frame in a coroutine?

easy

A. yield return new WaitForSeconds(1f);

B. yield return new WaitForEndOfFrame();

C. yield return WaitForEndOfFrame();

D. yield WaitForEndOfFrame();

Solution

1. Step 1: Recall correct syntax for WaitForEndOfFrame

   It requires creating a new instance: new WaitForEndOfFrame().

2. Step 2: Check other options for syntax errors

   yield return new WaitForSeconds(1f); waits seconds, not end of frame. yield return WaitForEndOfFrame(); misses 'new'. yield WaitForEndOfFrame(); misses 'return' and 'new'.

3. Final Answer:

   yield return new WaitForEndOfFrame(); -> Option B

4. Quick Check:

   Correct syntax = yield return new WaitForEndOfFrame() [OK]

Hint: Always use 'yield return new' with WaitForEndOfFrame [OK]

Common Mistakes:

• Omitting 'new' keyword
• Forgetting 'yield return'
• Using WaitForEndOfFrame like a method without 'new'

3. What will be the output order of the following Unity coroutine code?

IEnumerator Example() {
    Debug.Log("Start");
    yield return new WaitForEndOfFrame();
    Debug.Log("End of Frame");
    yield return new WaitForSeconds(1f);
    Debug.Log("After 1 second");
}

medium

A. "End of Frame" -> "Start" -> "After 1 second"

B. "Start" -> "After 1 second" -> "End of Frame"

C. "Start" -> "End of Frame" -> "After 1 second"

D. "After 1 second" -> "Start" -> "End of Frame"

Solution

1. Step 1: Trace the coroutine execution order

   First, "Start" logs immediately. Then it waits until the end of the frame, logs "End of Frame". Then waits 1 second, logs "After 1 second".

2. Step 2: Confirm output sequence

   The logs appear in order: Start, End of Frame, After 1 second.

3. Final Answer:

   "Start" -> "End of Frame" -> "After 1 second" -> Option C

4. Quick Check:

   WaitForEndOfFrame runs before WaitForSeconds delay [OK]

Hint: WaitForEndOfFrame logs before WaitForSeconds delay [OK]

Common Mistakes:

• Assuming WaitForSeconds runs before WaitForEndOfFrame
• Mixing log order
• Ignoring yield return pauses

4. Identify the error in this coroutine code snippet:

IEnumerator WaitExample() {
    Debug.Log("Before wait");
    yield WaitForSeconds(2f);
    Debug.Log("After wait");
}

medium

A. Missing 'new' keyword before WaitForSeconds.

B. Coroutine cannot use yield statements.

C. WaitForSeconds cannot be used in coroutines.

D. Debug.Log statements are not allowed in coroutines.

Solution

1. Step 1: Check syntax for WaitForSeconds usage

   WaitForSeconds must be instantiated with 'new', so it should be 'yield return new WaitForSeconds(2f);'.

2. Step 2: Verify other statements

   Coroutines can use yield statements and Debug.Log is allowed anywhere.

3. Final Answer:

   Missing 'new' keyword before WaitForSeconds. -> Option A

4. Quick Check:

   Always use 'yield return new WaitForSeconds()' [OK]

Hint: Remember 'yield return new' for WaitForSeconds [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using 'yield' without 'return'
• Thinking Debug.Log is invalid in coroutines

5. You want to update a UI element exactly after the current frame finishes rendering, then wait 0.5 seconds before updating it again. Which coroutine sequence correctly achieves this?

hard

A. yield return new WaitForSeconds(0.5f);
UpdateUI();
yield return new WaitForEndOfFrame();
UpdateUI();

B. UpdateUI();
yield return new WaitForSeconds(0.5f);
yield return new WaitForEndOfFrame();
UpdateUI();

C. yield return new WaitForEndOfFrame();
yield return new WaitForSeconds(0.5f);
UpdateUI();
UpdateUI();

D. yield return new WaitForEndOfFrame();
UpdateUI();
yield return new WaitForSeconds(0.5f);
UpdateUI();

Solution

1. Step 1: Understand the timing requirements

   The UI should update right after the frame ends, so first wait for WaitForEndOfFrame, then update UI.

2. Step 2: Wait 0.5 seconds before next update

   After the first update, wait 0.5 seconds using WaitForSeconds, then update UI again.

3. Step 3: Match the correct sequence

   yield return new WaitForEndOfFrame(); UpdateUI(); yield return new WaitForSeconds(0.5f); UpdateUI(); matches this order: WaitForEndOfFrame -> UpdateUI -> WaitForSeconds(0.5) -> UpdateUI.

4. Final Answer:

   yield return new WaitForEndOfFrame(); UpdateUI(); yield return new WaitForSeconds(0.5f); UpdateUI(); -> Option D

5. Quick Check:

   EndOfFrame first, then WaitForSeconds delay [OK]

Hint: Update after frame ends, then wait seconds before next update [OK]

Common Mistakes:

• Updating UI before WaitForEndOfFrame
• Mixing order of waits and updates
• Calling UpdateUI twice without wait