Unity: What is a Coroutine and why is there an IEnumerator

The title of the article is a question I was asked in an interview for a Middle position. In this article, we will look at Unity coroutines, what they are, and at the same time we will capture the topic of Enumerator \ Enumerable in C # and a little secret of foreach. The article should be very useful for beginners.

And so, as everyone knows, the method that represents Coroutine in Unity looks like this:

IEnumerator Coroutine()
{
  yield return null;
}

It returns an IEnumerator and has an unusual return with yield.
yield return is a component of IEnumerator, this bundle is converted, at compilation, into a state machine that saves the position in the code, waits for the MoveNext command from IEnumerator and continues execution until the next yield return or the end of the method, more details can be found on the microsoft site.

The IEnumerator interface contains the following elements:

public interface IEnumerator
{
  object Current { get; }

  bool MoveNext();
  void Reset();
}

Under the hood of Unity, this is handled something like this: Unity receives an IEnumerator, which is passed through StartCoroutine(IEnumerator), immediately calls MoveNext, in order for the code to reach the first yield return, it is worth clarifying here that when such a method is called, the execution of the code inside the method does not start independently, and you need to call MoveNext, this can be checked with a simple script, which is presented under this paragraph, and then if Unity receives an object of type YieldInstruction in Current, then it executes the instruction and calls MoveNext again, that is, the method can return any type, and if it not a YieldInstruction, then Unity will treat it as yield return null.

private IEnumerator _coroutine;

// Start is called before the first frame update
void Start()
{
  _coroutine = Coroutine();
}

// Update is called once per frame
void Update()
{
  if (Time.time > 5)
    _coroutine.MoveNext();
}

IEnumerator Coroutine()
{
  while (true)
  {
    Debug.Log(Time.time);
    yield return null;
  }
}

Great, we covered the main point, namely what is IEnumerator and how it works. Now let's look at this case:

Let's describe a class that inherits the IEnumerator interface

class TestEnumerator : IEnumerator
{
    public object Current => new WaitForSeconds(1);
		
    public bool MoveNext()
    {
        Debug.Log(Time.time);
        return true;
    }

    public void Reset()
    {
    }
    
    /// This class is equivalent to the following coroutine:
    /// IEnumerator Coroutine()
    /// {
    /// 	while(true){
    ///			Debug.Log(Time.time);
    ///			yield return new WaitForSeconds(1);
    /// 	}
    ///	}
}

And now we can use it in the following way:

void Start()
{
  StartCoroutine(new TestEnumerator());
}

And so, we have considered IEnumerator and coroutines, here you can consider different use cases for a long time, but at the root there remains the transfer of IEnumerator in any form to the StartCoroutine method.

Now I propose to consider IEnumerable, this interface is inherited by the native C# array, List from System.Generic and other similar types, its whole essence lies in the fact that it contains the GetEnumerator method, which returns an IEnumerator:

public interface IEnumerable
{
  [DispId(-4)]
  IEnumerator GetEnumerator();
}

Let's implement a simple example:

class TestEnumerable : IEnumerable
{
    public IEnumerator GetEnumerator()
    {
        return new TestEnumerator();
    }
}

And now, we can do the following:

IEnumerator Coroutine()
{
  foreach (var delay in new TestEnumerable())
  {
    Debug.Log($"{Time.time}");
    yield return delay;
  }
}

There are many usages for this, for example, you can add a random delay time to the TestEnumerator:

class TestEnumerator : IEnumerator
{
    public object Current => new WaitForSeconds(_currDelay);
    private float _currDelay;

    public bool MoveNext()
    {
        _currDelay = Random.Range(1.0f, 3.0f);
        return true;
    }

    public void Reset()
    {
    }
}

And some magic for beginners: foreach does not require that the object returned by GetEnumerator implement IEnumerable, most importantly, that the type after "in" has GetEnumerator() method, and returns a type with Current property and MoveNext() method, that is, we can do so:

class TestEnumerator // Here was inheritance from IEnumerator
{
    public object Current => new WaitForSeconds(_currDelay);
    private float _currDelay;

    public bool MoveNext()
    {
        _currDelay = Random.Range(1.0f, 3.0f);
        return true;
    }
  
  	// There was the Reset method from IEnumerator, it's no longer needed :)
}

class TestEnumerable // Here was inheritance from IEnumerable
{
  	// The return type was IEnumerator
    public TestEnumerator GetEnumerator()
    {
        return new TestEnumerator();
    }
}

As you can see, there is no inheritance anywhere and no mention of IEnumerable and IEnumerator, but we can also use the following code:

IEnumerator Coroutine()
{
  foreach (var delay in new TestEnumerable())
  {
    Debug.Log($"{Time.time}");
    yield return delay;
  }
}

And so, having analyzed the coroutines, IEnumerator, IEnumerable and foreach, you should see an example of using this knowledge in practice:

I would be grateful for criticism and comments, I also advise you to look at my other articles.

Translated for TechNation GlobalTalent Visa.