Работа с Корутинами в Unity

Корутины (Coroutines, сопрограммы) в Unity — простой и удобный способ запускать функции, которые должны работать параллельно в течение некоторого времени. В работе с корутинами ничего принципиально сложного нет и интернет полон статей с поверхностным описанием их работы. Тем не менее, мне так и не удалось найти ни одной статьи, где описывалась бы возможность запуска группы корутинов с продолжением работы после их завершения.
Хочу предложить вам небольшой паттерн, реализующий такую возможность, а также подбор информации о корутинах.

Корутины представляют собой простые C# итераторы, возвращающие IEnumerator и использующие ключевое слово yield. В Unity корутины регистрируются и выполняются до первого yield с помощью метода StartCoroutine. Дальше Unity опрашивает зарегистрированные корутины после каждого вызова Update и перед вызовом LateUpdate, определяя по возвращаемому в yield значению, когда нужно переходить к следующему блоку кода.

Существует несколько вариантов для возвращаемых в yield значений:

Продолжить после следующего FixedUpdate:

yield return new WaitForFixedUpdate();

Продолжить после следующего LateUpdate и рендеринга сцены:

yield return new WaitForEndOfFrame();

Продолжить через некоторое время:

yield return new WaitForSeconds(0.1f); // продолжить примерно через 100ms

Продолжить по завершению другого корутина:

yield return StartCoroutine(AnotherCoroutine());

Продолжить после загрузки удаленного ресурса:

yield return new WWW(someLink);

Все прочие возвращаемые значения указывают, что нужно продолжить после прохода текущей итерации цикла Update:

yield return null;

Выйти из корутина можно так:

yield return break;

При использовании WaitForSeconds создается долгосуществующий объект в памяти (управляемой куче), поэтому его использование в быстрых циклах может быть плохой идеей.

Я уже написал, что корутины работают параллельно, следует уточнить, что они работают не асинхронно, то есть выполняются в том же потоке.

Простой пример корутина:

void Start()
{
	StartCoroutine(TestCoroutine());
}

IEnumerator TestCoroutine()
{
	while(true)
	{
		yield return null;
		Debug.Log(Time.deltaTime);
	}
}

Этот код запускает корутин с циклом, который будет писать в консоль время, прошедшее с последнего фрейма.
Следует обратить внимание на то, что в корутине сначала вызывается yield return null, и только потом идет запись в лог. В нашем случае это имеет значение, потому что выполнение корутина начинается в момент вызова StartCoroutine(TestCoroutine()), а переход к следующему блоку кода после yield return null будет осуществлён после метода Update, так что и до и после первого yield return null Time.deltaTime будет указывать на одно и то же значение.

Также нужно заметить, что корутин с бесконечным циклом всё еще можно прервать, вызвав StopAllCoroutines(), StopCoroutine(«TestCoroutine»), или уничтожив родительский GameObject.

Хорошо. Значит с помощью корутинов мы можем создавать триггеры, проверяющие определенные значения каждый фрейм, можем создать последовательность запускаемых друг за другом корутинов, к примеру, проигрывание серии анимаций, с различными вычислениями на разных этапах. Или просто запускать внутри корутина другие корутины без yield return и продолжать выполнение. Но как запустить группу корутинов, работающих параллельно, и продолжить только по их завершению?

Конечно, вы можете добавить классу, в котором определен корутин, переменную, указывающую на текущее состояние:

Класс, который нужно двигать:

public bool IsMoving = false;

IEnumerator MoveCoroutine(Vector3 moveTo)
{
	IsMoving = true;
	
	// делаем переход от текущей позиции к новой
	var iniPosition = transform.position;
	while (transform.position != moveTo)
	{
		// тут меняем текущую позицию с учетом скорости и прошедшего с последнего фрейма времени
		// и ждем следующего фрейма
		yield return null;
	}
	
	IsMoving = false;
}

Класс, работающий с группой классов, которые нужно двигать:

IEnumetaror PerformMovingCoroutine()
{
	// делаем дела

	foreach(MovableObjectScript s in objectsToMove)
	{
		// определяем позицию
		StartCoroutine(s.MoveCoroutine(moveTo));
	}

	bool isMoving = true;
	while (isMoving) 
	{
		isMoving = false;
		Array.ForEach(objectsToMove, s => { if (s.IsMoving) isMoving = true; }
		if (isMoving) yield return null;
	}

	// делаем еще дела
}

Блок «делаем еще дела» начнет выполнятся после завершения корутина MoveCoroutine у каждого объекта в массиве objectsToMove.

Что ж, уже интересней.
А что, если мы хотим создать группу корутинов, с возможностью в любом месте и в любое время проверить, завершила ли группа работу?
Сделаем!

Для удобства сделаем всё в виде методов расширения:

public static class CoroutineExtension
{
	// для отслеживания используем словарь <название группы, количество работающих корутинов>
	static private readonly Dictionary<string, int> Runners = new Dictionary<string, int>();

	// MonoBehaviour нам нужен для запуска корутина в контексте вызывающего класса
	public static void ParallelCoroutinesGroup(this IEnumerator coroutine, MonoBehaviour parent, string groupName)
	{
		if (!Runners.ContainsKey(groupName))
			Runners.Add(groupName, 0);

		Runners[groupName]++;
		parent.StartCoroutine(DoParallel(coroutine, parent, groupName));
	}
	

	static IEnumerator DoParallel(IEnumerator coroutine, MonoBehaviour parent, string groupName)
	{
		yield return parent.StartCoroutine(coroutine);
		Runners[groupName]--;
	}
	
	// эту функцию используем, что бы узнать, есть ли в группе незавершенные корутины
	public static bool GroupProcessing(string groupName)
	{
		return (Runners.ContainsKey(groupName) && Runners[groupName] > 0);
	}
}

Теперь достаточно вызывать на корутинах метод ParallelCoroutinesGroup и ждать, пока метод CoroutineExtension.GroupProcessing возвращает true:

public class CoroutinesTest : MonoBehaviour
{

	// Use this for initialization
	void Start()
	{
		StartCoroutine(GlobalCoroutine());
	}

	IEnumerator GlobalCoroutine()
	{
		for (int i = 0; i < 5; i++)
			RegularCoroutine(i).ParallelCoroutinesGroup(this, "test");

		while (CoroutineExtension.GroupProcessing("test"))
			yield return null;

		Debug.Log("Group 1 finished");

		for (int i = 10; i < 15; i++)
			RegularCoroutine(i).ParallelCoroutinesGroup(this, "anotherTest");

		while (CoroutineExtension.GroupProcessing("anotherTest"))
			yield return null;

		Debug.Log("Group 2 finished");
	}

	IEnumerator RegularCoroutine(int id)
	{
		int iterationsCount = Random.Range(1, 5);

		for (int i = 1; i <= iterationsCount; i++)
		{
			yield return new WaitForSeconds(1);
		}

		Debug.Log(string.Format("{0}: Coroutine {1} finished", Time.realtimeSinceStartup, id));
	}
}

Готово!

Автор: Deadcow

Источник