Yes, it is possible to do using iterators. I've put some pseudo C# code here to give you an idea. You use
yield return to return something from an iterator, which has the same behavior as
yield in a theoretical coroutine. You can then store the iterators in a list, dictionary, or other structure to keep track of them, and run them all. Note that coroutines are not a natively supported feature of C#, and are usually implemented using enumerators. I think Unity does it in the same way.
Running, Success, Failure
// An example of a coroutine that does something until some
// condition is true.
yield return Running;
yield return Success;
// Keeps track of all running coroutines, and runs them till the end.
List<IEnumerator<Status> > Coroutines = new List<Enumerator<Status> >();
// Starting a coroutine just means adding an enumerator to the list.
// You might also want to be able to stop coroutines or delete them,
// which might mean putting them into a dictionary
public void StartCoroutine(Func<IEnumerable<Status> > func)
// Updating just means stepping through all the coroutines
public void Update()
foreach(Enumerator<Status> routine in Coroutines)
You then just need to call
to begin the coroutine. Somewhere in your code you also need to call