koobas.hobune.stream
Coroutine in C# and Question
I'm just beginning to learn about coroutines and how they work. I tried testing this code:
void Update()
{
transform.Translate(.05f, 0, 0);
}
inside a coroutine:
void Update ()
{
StartCoroutine(test());
}
IEnumerator test()
{
transform.Translate(.05f,0,0);
yield return null;
}
Do these two codes suppose to act the same way? Because the coroutine code seems to "choke" a couple of times at the beginning
You shouldn't start a coroutine every update - it doesn't really do anything (apart from possibly run twice in the first frame) - but your coroutine does nothing useful - the yield return null has nothing following it (which is the part that would run on the next frame).
void Update()
{
if(Input.GetKeyDown("a"))
StartCoroutine(test());
}
IEnumerator test()
{
//Example
for(var i = 0; i < 20; i++)
{
transform.position += Vector3.right * Time.deltaTime;
yield return null;
}
}
With the response of @aldo and yours now i can understand clearly thanks.
Coroutines are functions that execute "in the background". When you start a coroutine, an "instance" of that routine is created and starts running until an yield statement is found: at this instruction, the coroutine is frozen and control returns to the caller (execution is resumed right after StartCoroutine ). The frozen coroutine automatically resumes execution next frame, right after the yield statement, and keeps running until a yield is found or the coroutine reaches its end.
Since a new coroutine instance is created for each StartCoroutine, doing this at Update usually is a bad practice: you're creating a new coroutine every frame, and the several instances may fight for the control of whatever they affect, given weird and unpredictable results.
But in this particular case, each test instance should immediately translate the object, freeze till the next frame, unfreeze and then peacefully die without any collateral effect - with exception of more frequent heap cleanup operations (garbage collections), which could cause some performance hiccups.
