Is a StartCoroutine needed for a call from inside one co-routine to another co-routine?

Question

When you have nested co-routines like

void Update()
{
    if(someTest)
    {
        StartCoroutine(Foo());
    }
}

IEnumerator Foo()
{
    doStuff = true;
    yield return StartCoroutine(Bar());
    doStuff = false;
}

IEnumerator Bar()
{
    //Very important things!
}

Is the StartCoroutine in yield return StartCoroutine(Bar()); necessary?

Are we allowed to just do

void Update()
{
    if(someTest)
    {
        StartCoroutine(Foo());
    }
}

IEnumerator Foo()
{
    doStuff = true;
    yield return Bar();
    doStuff = false;
}

IEnumerator Bar()
{
    //Very important things!
}

If we are allowed, does this have any impact on the program behavior/performance?

Answer 1

Is the StartCoroutine in yield return StartCoroutine(Bar()); necessary?

No, you are allowed to use yield return Bar();.

If we are allowed, does this have any impact on the program behavior/performance?

Yes to both behavior and performance question.

The Difference:

---

yield return StartCoroutine(coroutineFunction()):

• Inner coroutine(Bar) will be started before yielding
• Memory Allocation: 56 bytes
• Calls: 2
• When a parent coroutine is killed, the child coroutine that is started with StartCoroutine continues to run.

---

yield return coroutineFunction():

• Inner coroutine(Bar) will be started after yielding
• Memory Allocation: 32 bytes
• Calls: 3
• When a parent coroutine is killed, the child coroutine that is started with yield return coroutineFunction() is killed as well. This is every important to know especially when you need to stop a parent coroutine with its children.

• Faster:

  Probably because it allocates less memory. When used in a for loop it is faster than yield return StartCoroutine(coroutineFunction()). This is even true even though it has more calls. Also, Time and Self ms from the Profiler shows that its values are less than the ones from yield return StartCoroutine(coroutineFunction()).

In conclusion:

The yielding difference is almost like the i++ vs ++i (post and pre increment). If you care about memory management then go with the second method yield return coroutineFunction() as it allocates less memory. Also if you want to be able to stop all the inner or child coroutines when the parent one is stopped then also use yield return coroutineFunction().