часто ссылается Unity3D сопрограммы в деталях ссылка мертвая. Поскольку это упоминается в комментариях и ответах, я собираюсь опубликовать содержание статьи здесь. Этот контент исходит от это зеркало.

---

Unity3D сопрограммы в деталях

многие процессы в игре происходят в течение нескольких кадров. У вас есть "плотные" процессы, такие как поиск пути, которые усердно работают каждый кадр, но получают разделить на несколько кадров, чтобы не влиять на частоту кадров слишком сильно. У вас есть "разреженные" процессы, такие как триггеры геймплея, которые ничего не делают в большинстве кадров, но иногда призваны выполнять критическую работу. И у вас есть различные процессы между ними.

всякий раз, когда вы создаете процесс, который будет проходить через несколько кадров – без многопоточности – вам нужно найти какой-то способ разбить работу на куски, которые можно запускать по одному кадру. Для любого алгоритм с центральным циклом, это довольно очевидно: a * pathfinder, например, может быть структурирован таким образом, что он поддерживает свои списки узлов полупостоянно, обрабатывая только несколько узлов из открытого списка каждого кадра, вместо того, чтобы пытаться выполнить всю работу за один раз. Существует некоторая балансировка для управления задержкой – в конце концов, если вы блокируете частоту кадров на 60 или 30 кадров в секунду, то ваш процесс будет выполнять только 60 или 30 шагов в секунду, и это может привести к тому, что процесс просто слишком долго в целом. Аккуратный дизайн может предложить наименьшую возможную единицу работы на одном уровне – например, обработать один узел A* – и слой сверху способ группировки работы вместе в более крупные куски – например, продолжать обрабатывать узлы a* в течение X миллисекунд. (Некоторые люди называют это "timeslicing", хотя я этого не делаю).

тем не менее, позволяя работе разбиваться таким образом, вы должны передавать состояние от одного кадра к другому. Если вы нарушаете итерационный алгоритм, то вы должны сохранить все состояния, разделяемые между итерациями, а также средства отслеживания, какая итерация должна быть выполнена дальше. Обычно это не так уж плохо – дизайн класса "A * pathfinder" довольно очевиден, но есть и другие случаи, которые менее приятны. Иногда вы будете сталкиваться с длинными вычислениями, которые выполняют разные виды работы от кадра к кадру; объект, фиксирующий их состояние, может в конечном итоге привести к большому беспорядку полуполезных "локальных", сохраняемых для передачи данных из один кадр за другим. И если вы имеете дело с разреженным процессом, вам часто приходится реализовывать небольшую машину состояний, чтобы отслеживать, когда работа должна быть выполнена вообще.

было бы неплохо, если бы вместо того, чтобы явно отслеживать все это состояние в нескольких кадрах, и вместо того, чтобы многопоточно управлять синхронизацией и блокировкой и т. д., Вы могли бы просто написать свою функцию как один кусок кода и отметить определенные места, где функция должна быть "пауза" и продолжить в более позднее время?

Unity-наряду с рядом других сред и языков – обеспечивает это в виде сопрограмм.

как они выглядят? В "Unityscript" (Javascript):

function LongComputation()
{
    while(someCondition)
    {
        /* Do a chunk of work */

        // Pause here and carry on next frame
        yield;
    }
}

В C#:

IEnumerator LongComputation()
{
    while(someCondition)
    {
        /* Do a chunk of work */

        // Pause here and carry on next frame
        yield return null;
    }
}

как они работают? Позвольте мне сразу сказать, что я не работаю на Unity Technologies. Я не видел исходный код Unity. Я никогда не видел мужества из сопрограммного двигателя Unity. Однако, если они реализовали его таким образом, который радикально отличается от того, что я собираюсь описать, то я буду очень удивлен. Если кто-то из UT хочет перезвонить и поговорить о том, как это на самом деле работает, то это было бы здорово.

Большие Ключи в версии C#. Во-первых, обратите внимание, что тип возвращаемого значения для функции интерфейс IEnumerator. А во-вторых, обратите внимание, что одно из утверждений является доходность возвращаться. Это означает, что yield должен быть ключевым словом, а поскольку поддержка Unity C# - это vanilla C# 3.5, это должно быть ключевое слово vanilla C# 3.5. Действительно,вот он в MSDN – говоря о чем-то под названием " итератор блоков.- Так что же происходит?

во-первых, есть этот тип IEnumerator. Тип IEnumerator действует как курсор над последовательностью, предоставляя два важных элемента: Current, который является свойством, дающим вам элемент, над которым в настоящее время находится курсор, и MoveNext (), функция, которая перемещается к следующему элементу в последовательность. Поскольку IEnumerator-это интерфейс, он не указывает точно, как эти члены реализуются; MoveNext() может просто добавить один toCurrent, или он может загрузить новое значение из файла, или он может загрузить изображение из интернета и хэшировать его и сохранить новый хэш в текущем... или он может даже сделать одну вещь для первого элемента в последовательности, и что-то совершенно другое для второго. Вы даже можете использовать его для создания бесконечной последовательности, если вы так хотите. метод MoveNext() вычисляет следующее значение в последовательности (возвращает false, если больше нет значений), а Current извлекает вычисленное значение.

обычно, если вы хотите реализовать интерфейс, вам придется написать класс, реализуют члены, и так далее. Блоки итератора-это удобный способ реализации IEnumerator без всех этих хлопот – вы просто следуете нескольким правилам, и реализация IEnumerator автоматически генерируется компилятором.

An блок итератора-это регулярная функция, которая (a) возвращает IEnumerator и (b) использует ключевое слово yield. Так что же на самом деле делает ключевое слово yield? Он объявляет следующее значение в последовательности - или что больше нет значений. Точка, в которой код встречает выход return X или yield break-это точка, в которой находится IEnumerator.Метод MoveNext() следует прекратить; урожай возвращения X вызывает метод MoveNext (), чтобы возвратить True andCurrent быть присвоено значение Х, при урожайности перерыв вызывает MoveNext () к возвращать false.

сейчас, вот в чем фокус. Это не должно иметь значения, каковы фактические значения, возвращаемые последовательностью. Вы можете вызвать MoveNext() повторно и игнорировать Current; вычисления все равно будут выполняться. Каждый раз, когда вызывается MoveNext (), ваш блок итератора переходит к следующему оператору yield, независимо от того, какое выражение он фактически дает. Так что вы можете написать что-то вроде:

IEnumerator TellMeASecret()
{
  PlayAnimation("LeanInConspiratorially");
  while(playingAnimation)
    yield return null;

  Say("I stole the cookie from the cookie jar!");
  while(speaking)
    yield return null;

  PlayAnimation("LeanOutRelieved");
  while(playingAnimation)
    yield return null;
}

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

IEnumerator e = TellMeASecret();
while(e.MoveNext()) { }

или, что более полезно, вы можете смешать его с другой работой:

IEnumerator e = TellMeASecret();
while(e.MoveNext()) 
{ 
  // If they press 'Escape', skip the cutscene
  if(Input.GetKeyDown(KeyCode.Escape)) { break; }
}

все дело в сроках Как вы видели, каждый оператор yield return должен предоставлять выражение (например, null), чтобы блок итератора имел что-то на самом деле назначить IEnumerator.Текущий. Длинная последовательность нулей не совсем полезна, но нас больше интересуют побочные эффекты. Разве нет?

есть что-то удобное, что мы можем сделать с этим выражением, на самом деле. Что делать, если вместо того, чтобы просто давать null и игнорируя это, мы дали что-то, что указывало, когда мы ожидаем, что нам нужно сделать больше работы? Часто нам нужно будет переносить прямо на следующий кадр, конечно, но не всегда: будет много раз, когда мы хотите продолжить после того, как анимация или звук закончили играть, или после определенного количества времени прошло. Те в то время как (playingAnimation) yield return null; конструкции немного утомительны, не так ли?

Unity объявляет базовый тип YieldInstruction и предоставляет несколько конкретных производных типов, которые указывают на определенные виды ожидания. У вас есть WaitForSeconds, который возобновляет сопрограмму после того, как указанное количество времени прошло. У вас есть WaitForEndOfFrame, который возобновляет сопрограмму в определенной точке позже в том же кадре. У вас есть сам тип сопрограммы, который, когда сопрограмма A дает сопрограмму B, приостанавливает сопрограмму A до тех пор, пока сопрограмма B не закончит.

как это выглядит с точки зрения среды выполнения? Как я уже сказал, Я не работаю для Unity, поэтому я никогда не видел их код; но я бы предположил, что это может выглядеть немного так:

List<IEnumerator> unblockedCoroutines;
List<IEnumerator> shouldRunNextFrame;
List<IEnumerator> shouldRunAtEndOfFrame;
SortedList<float, IEnumerator> shouldRunAfterTimes;

foreach(IEnumerator coroutine in unblockedCoroutines)
{
    if(!coroutine.MoveNext())
        // This coroutine has finished
        continue;

    if(!coroutine.Current is YieldInstruction)
    {
        // This coroutine yielded null, or some other value we don't understand; run it next frame.
        shouldRunNextFrame.Add(coroutine);
        continue;
    }

    if(coroutine.Current is WaitForSeconds)
    {
        WaitForSeconds wait = (WaitForSeconds)coroutine.Current;
        shouldRunAfterTimes.Add(Time.time + wait.duration, coroutine);
    }
    else if(coroutine.Current is WaitForEndOfFrame)
    {
        shouldRunAtEndOfFrame.Add(coroutine);
    }
    else /* similar stuff for other YieldInstruction subtypes */
}

unblockedCoroutines = shouldRunNextFrame;

это не трудно представить, как дополнительные подтипы YieldInstruction могут быть добавлены для обработки других случаев-например, может быть добавлена поддержка сигналов на уровне ядра с поддержкой WaitForSignal("SignalName")YieldInstruction. Добавляя больше YieldInstructions, сами сопрограммы могут стать более выразительными-yield возврат нового WaitForSignal ("GameOver") приятнее читать, чем while (!Сигналы.HasFired ("GameOver")) yield return null, если вы спросите меня, совсем не считая того, что делать это в движке можно было бы быстрее чем делать это в сценарии.

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

во – первых, yield return просто дает выражение – любое выражение-и YieldInstruction является регулярным типом. Это означает, что вы можете делать вещи, как:

YieldInstruction y;

if(something)
 y = null;
else if(somethingElse)
 y = new WaitForEndOfFrame();
else
 y = new WaitForSeconds(1.0f);

yield return y;

конкретный строк возврата новый WaitForSeconds(), доходность вернуть новое WaitForEndOfFrame () и т. д. являются общими, но на самом деле они не являются специальными формами сами по себе.

во – вторых, поскольку эти сопрограммы являются просто блоками итераторов, вы можете перебирать их самостоятельно, если хотите-вам не нужно, чтобы двигатель делал это за вас. Я использовал это для добавления условий прерывания в сопрограмму раньше:

IEnumerator DoSomething()
{
  /* ... */
}

IEnumerator DoSomethingUnlessInterrupted()
{
  IEnumerator e = DoSomething();
  bool interrupted = false;
  while(!interrupted)
  {
    e.MoveNext();
    yield return e.Current;
    interrupted = HasBeenInterrupted();
  }
}

в-третьих, тот факт, что вы можете уступить другим сопрограммам, может позволить вам реализовать свои собственные YieldInstructions, хотя и не так эффективно, как если бы они были реализованы двигателем. Например:

IEnumerator UntilTrueCoroutine(Func fn)
{
   while(!fn()) yield return null;
}

Coroutine UntilTrue(Func fn)
{
  return StartCoroutine(UntilTrueCoroutine(fn));
}

IEnumerator SomeTask()
{
  /* ... */
  yield return UntilTrue(() => _lives < 3);
  /* ... */
}

однако, я бы не очень рекомендовал это – стоимость запуска сопрограммы немного тяжеловата на мой вкус.

вывод Я надеюсь, что это немного проясняет некоторые из того, что происходит на самом деле, когда вы используете сопрограмму в Unity. Блоки итератора C# - это отличная маленькая конструкция, и даже если вы не используете Unity, возможно, вы будете найти его полезным, чтобы воспользоваться ими таким же образом.