Can't reuse WaitForSecondsRealtime

I have the habit of caching WaitForSeconds instances to avoid unnecessary Garbage Collection calls as this is an easy optimization to do. The pattern is as follows:

Code (CSharp):

1. WaitForSeconds Wait;
2.  
3. // ...
4.  
5. IEnumerator DummyCoroutine() {
6.     yield return Wait;
7. }

More info on why this is done can be seen in this thread.

However, if I try to follow the same pattern using WaitForSecondsRealtime, it works only the first time it is returned. It is as if WaitForSecondsRealtime is retaining state and can't be reused.

I don't know if caching these waits is a good practice or not, nevertheless, that is clearly an inconsistent behaviour and I think it might be a bug. Has anyone come across this issue? I am using Unity 2017.4.6f1

 

I don't know why you are having this issue, but I can confirm that this practice is actually in Unity's official guide for optimising your code to reduce garbage collection.

You can find it here in the section on Coroutines:

 

Nice, I didn't know this pattern was encouraged by Unity developers. So, my issue happens exclusively with WaitForSecondsRealtime. I opened the thread to know whether this is a bug or a mistake of mine. If someone else can confirm this behaviour for me I will gladly open a bug report

 

I was able to reproduce it in 2018.2, so it does seem to be an ongoing bug. I used the following code:

Code (CSharp):

1. using System.Collections;
2. using UnityEngine;
3.  
4. public class Waitforseconds : MonoBehaviour {
5.  
6.     WaitForSecondsRealtime _wait;
7.  
8.     private void Start()
9.     {
10.         _wait = new WaitForSecondsRealtime(3f);
11.         StartCoroutine(CoroutineWait());
12.     }
13.  
14.     private IEnumerator CoroutineWait()
15.     {
16.         while (true)
17.         {
18.             Debug.Log("TICK");
19.             yield return _wait;
20.         }
21.     }
22. }
23.  

The behaviour I saw was that it would tick once, wait three seconds, then just start logging every tick after that. Is this consistent with the behaviour you were seeing?

 

Exactly! Thank you

Just sent a bug report

 

Not fixed in Unity 2017.x . We have not access to waitTime property.

Edit: Implement my Own custom yield instruction thanks to your sample.

 

In Unity 2018.3.12f1 I am seeing odd behavior when trying to reuse a WaitForSecondsRealtime(), when used in conjunction with StopCoroutine.

I have a pause menu, with a countdown that resumes the game after X seconds. I have an option to override the countdown to unpause the game immediately. When I use the override option, then pause the game again, and resume again, the countdown for the first number is definitely not 1 realtime second.

I tried using the waitTime property mentioned above, to reset the coroutine after stopping the coroutine, but that did not help. The only thing that works is generating a new WaitForSecondsRealtime() instead of reusing the existing.

Is this a bug, or intentional on Unity's part?

 

Say you have a centralized pool of different WaitForSecondsRealtime instances and you tend to use 1 second wait here and there in your project. If one coroutine starts a wait of 1 second at t=0 and second coroutine starts a wait of 1 second at t=0.5sec, with simple pooling they both would be using the same WaitForSecondsRealtime instance.

The problem then would be that the wait of the second coroutine would terminate only after 0.5sec, which is the time when the first coroutine is expected to terminate. So if this kind of WaitForSecondsRealtime instances are to be reused, the user needs to keep in track which ones are currently in use and only allow reusing them after they have returned back to state where m_WaitUntilTime==-1.