Unity 2022.2 продолжает интеграцию async await

В Unity 2022.2 был сделан ещё один небольшой шаг в сторону поддержки async-await, анонсированный еще в мае 2022 года в статье https://blog.unity.com/technology/unity-and-net-whats-next. В UnityEngine.MonoBehaviour было добавлено свойство destroyCancellationToken, которое позволяет остановить задачу в момент уничтожения объекта. В UnityEngine.Application добавлено свойство с токеном exitCancellationToken, который отменяется в момент выхода из Play Mode. Коротко вспомним отличие Coroutine от async-await и применим новые свойства.

Пример использования Coroutine

Coroutine, по сути, это простые IEnumerator-методы, которые итерируются в Player Loop всегда в главном потоке. Из Coroutine вы можете вернуть null или 4 типа объекта: WaitForSeconds, WaitForFixedUpdate, WWW или же какой-то другой Coroutine. В зависимости от типа можно точно предсказать, когда произойдет возврат в метод. Это можно посмотреть на схеме https://docs.unity3d.com/Manual/ExecutionOrder.html. Если возвращаемый объект не будет относиться ни к одному из перечисленных, то он будет воспринят как null.

Каждый Coroutine строго привязан к MonoBehaviour, которым он вызывается. Так к примеру, если game object будет выключен или будет отключен сам MonoBehaviour, то и вызов Coroutine не будет происходить. При уничтожении объекта, Coroutine вовсе перестает как либо обрабатываться.

Это дает удобство, но и вносит свои ограничения. К примеру, вы уже не можете управлять постоянным включением и выключением объекта через Coroutine самого объекта. Только через какой-то внешний объект.

Приведу пример с мигающими объектами на сцене. Создадим такой компонент.

public class BlinkingObject : MonoBehaviour {     public float period;      public IEnumerator Start()     {         var delay = new WaitForSeconds(period);                  while (true)         {             yield return delay;             gameObject.SetActive(false);             yield return delay;             gameObject.SetActive(true);         }     } }

Выполнение этого компонента приведёт только к отключению объекта, и он никогда не включится вновь. Т.к. возврат в Coroutine на выключенном объекте не произойдёт. Классическое решение данной ситуации — это управление мигающим объектом извне.

public class BlinkingObject : MonoBehaviour {     public float period = 1;     public GameObject target;      public IEnumerator Start()     {         var delay = new WaitForSeconds(period);                  while (true)         {             yield return delay;             target.SetActive(false);             yield return delay;             target.SetActive(true);         }     } }

Тут один объект будет управлять другим, который был указан в target. Опять же, если указать для него самого себя, то скрипт работать не будет. Хорошим тоном будет сделать проверку.

if (target == gameObject) {     throw new Exception(         $"Specified {nameof(GameObject)} in the variable {nameof(target)} of {nameof(BlinkingObject)} " +         $"on the '{gameObject.name}' {nameof(GameObject)} is the same as the parent one."); }

В большинстве других случаев подобная взаимосвязь Coroutine и MonoBehaviour удобна. Любое управление движением объекта через Coroutine будет остановлено, как только объект будет выключен или уничтожен.

Пример использование async await для создания мигающего объекта

В какой поток будет передано управление после await зависит от используемого SynchronizationContext. В Unity await всегда возвращает управление в основной поток, что и требуется в большинстве случаев.

Напишем компонент для управления миганием объекта через async-await.

public class BlinkingObject : MonoBehaviour {     public int period = 1;      public async void Start()     {         // Converts seconds to milliseconds.         var delay = period * 1000;                   while (true)         {             await Task.Delay(delay);                          if (this == null)             {                 break;             }                          gameObject.SetActive(false);             await Task.Delay(delay);                          if (this == null)             {                 break;             }                          gameObject.SetActive(true);         }     } }

После каждого использования Task.Delay приходится делать проверку на то, был ли уничтожен объект.

if (this == null) {     break; }

В такой ситуации лучше использовать CancellationToken, чтобы отменять выполнение Task, сразу как только объект был уничтожен. Следующий пример будет использовать свойство MonoBehaviour.destroyCancellationToken, которое было добавлено в Unity 2022.2.

public class BlinkingObject : MonoBehaviour {     public int period = 1;      public async void Start()     {         // Converts seconds to milliseconds.         var delay = period * 1000;                   while (!destroyCancellationToken.IsCancellationRequested)         {             await Task.Delay(delay, destroyCancellationToken);             gameObject.SetActive(false);             await Task.Delay(delay, destroyCancellationToken);             gameObject.SetActive(true);         }     } }

Однако, отмена Task вызывает TaskCanceledException, который мы и получим, если просто уничтожим объект в момент выполнения. Следует избегать async-void методов. Если в методе нет полезного результата, то он должен возвращать Task. Если, всё-таки нет возможности сделать такой метод, как в примере с void Start(), выполнение следует оборачивать в try-catch.

public class BlinkingObject : MonoBehaviour {     public int period = 1;      public async void Start()     {         try         {             await BlinkAsync();         }         catch (TaskCanceledException) { }     }      private async Task BlinkAsync()     {         // Converts seconds to milliseconds.         var delay = period * 1000;                   while (!destroyCancellationToken.IsCancellationRequested)         {             await Task.Delay(delay, destroyCancellationToken);             gameObject.SetActive(false);             await Task.Delay(delay, destroyCancellationToken);             gameObject.SetActive(true);         }     } }

При таком подходе нет нужды беспокоиться будет ли объект включен или выключен, управление будет возвращаться в метод в любом случае, а при уничтожении выполнение остановится. При этом код получился достаточно компактным. К примеру, раньше обработку токена destroyCancellationToken приходилось бы делать вручную.

using System.Threading; using System.Threading.Tasks; using UnityEngine;  public class BlinkingObject : MonoBehaviour {     ...      private CancellationTokenSource _cancellationTokenSource;      private CancellationToken DestroyCancellationToken => _cancellationTokenSource.Token;      private async void Start()     {         _cancellationTokenSource = new CancellationTokenSource();                  ...             }      private void OnDestroy()     {         _cancellationTokenSource.Cancel();         _cancellationTokenSource.Dispose();     }      private async Task BlinkAsync()     {         ...     } }

Использование async-await в отрыве от MonoBehaviour

При работе с Unity мы можем сталкиваться со множеством других библиотек и пакетов, которые могут использовать async-await подход. Или когда мы создаем асинхронную задачу в отрыве от игровых объектов, например, для реализации какой-от другой игровой логики. Начиная с Unity 2022.2, можно будет использовать UnityEngine.Application.exitCancellationToken для их своевременной остановки.

Приведу гипотетический пример ранней инициализации игры.

public static class Boot {     [RuntimeInitializeOnLoadMethod]     public static async void Initialization()     {         try         {             await StartGameAsync(Application.exitCancellationToken);         }         catch (OperationCanceledException) { }     }      private static async Task StartGameAsync(CancellationToken cancellationToken)     {         await SomeJobBeforeInitialization(cancellationToken);         await Addressables.InitializeAsync().Task;         await PreloadingSomeBundles(cancellationToken);         await Addressables.LoadSceneAsync("StartMenuScene").Task;     }      private static async Task SomeJobBeforeInitialization(CancellationToken cancellationToken)     {         await Task.Delay(1000, cancellationToken);     }      private static async Task PreloadingSomeBundles(CancellationToken cancellationToken)     {         await Task.Delay(1000, cancellationToken);     } }

До введения Application.exitCancellationToken приходилось делать обработку этого токена вручную. Напомню, что если просто так запустить async Task, без обработки отмены, то эта задача продолжит выполняться и после остановки игры при переходе в Edit Mode.

Сравнивая Coroutine и async-await

Ожидание Task через await  часто выделяют объекты в памяти, что может вызвать проблемы с производительностью, при частом использовании. Так при управлении игровыми объектам в Unity, несмотря на все удобства синтаксиса async-await, на мой взгляд, всё ещё предпочтительнее использовать Coroutine.

Одним из самых больших недостатков Coroutine — это невозможность вернуть результат. В такой ситуации уже можно обратиться к стандартному подходу в .NET с использование async-await.

Также можно создать свой собственный аналог Task более адаптированный для Unity и более производительный, который будет поддерживать внутреигровое время Time.time, Time.deltaTime и т.п. Но это — большая тема для отдельной статьи. На данный момент уже существует библиотека UniTask, которая совмещает в себе все удобства async-await и адаптированность под Unity.