c# - tag - unity static inspector

¿Es una nueva cadena de hilos en Unity3D?

Question

Estoy confundido y curioso acerca de cómo funcionan las coroutines (en Unity3D y quizás en otros lugares). ¿Es la coroutine un hilo nuevo? La coroutines de Unity decía:

Una coroutina es una función que puede suspender su ejecución (rendimiento) hasta que finalice la instrucción de rendimiento determinada.

Y tienen ejemplos de C # here :

using UnityEngine;
using System.Collections;
public class example : MonoBehaviour {
void Start() {
print("Starting " + Time.time);
StartCoroutine(WaitAndPrint(2.0F));
print("Before WaitAndPrint Finishes " + Time.time);
}
IEnumerator WaitAndPrint(float waitTime) {
yield return new WaitForSeconds(waitTime);
print("WaitAndPrint " + Time.time);
}
}

Tengo muchas preguntas sobre este ejemplo:

1. En el ejemplo anterior, ¿qué línea es la corutina? ¿Es WaitAndPrint() una coroutine? ¿Es WaitForSeconds() una coroutina?

2. En esta línea: yield return new WaitForSeconds(waitTime); ¿Por qué tanto el yield como el return están presentes? Leí en la documentación de Unity que "la declaración de rendimiento es un tipo especial de rendimiento, que garantiza que la función continuará desde la línea después de la declaración de rendimiento la próxima vez que se llame". Si el yield es un yield especial, ¿qué hace el return aquí?

3. ¿Por qué tenemos que devolver un IEnumerator ?

4. ¿ StartCoroutine inicia un nuevo hilo?

5. ¿Cuántas veces se ha WaitAndPrint() en el ejemplo anterior? ¿ yield return new WaitForSeconds(waitTime); realmente regresó? En caso afirmativo, entonces supongo que se llamó dos veces a WaitAndPrint() en el código anterior. Y supongo que StartCoroutine() estaba llamando a WaitAndPrint() varias veces. Sin embargo, vi here que dice: "La ejecución de una coroutine se puede pausar en cualquier punto usando la declaración de rendimiento. El valor de rendimiento de rendimiento especifica cuándo se reanuda la coroutine". Estas palabras me hacen sentir que WaitAndPrint() realidad no ha regresado; fue simplemente pausado; estaba esperando a que WaitForSeconds() regresara. Si este es el caso, entonces en el código anterior, se WaitAndPrint() solo una vez, y StartCoroutine solo fue responsable de iniciar la función, no de llamarla varias veces.

Answer 1

Coroutines es una técnica extremadamente poderosa utilizada para emular los tipos de funciones admitidas por async / await en .net4.5, pero en versiones anteriores (c #> = v2.0).

Microsoft CCR (toma una lectura) también emplea (¿empleado?) Este enfoque.

Vamos a sacar una cosa del camino. yield sí solo no es válido y siempre va seguido de return o break .

Piense en un IEnumerator estándar (que no produce mensajes de control de flujo).

IEnumerator YieldMeSomeStuff()
{
yield "hello";
Console.WriteLine("foo!");
yield "world";
}

Ahora:

IEnumerator e = YieldMeSomeStuff();
while(e.MoveNext())
{
Console.WriteLine(e.Current);
}

¿Cuál es la salida?

hello foo! world

Observe cómo, la segunda vez que llamamos MoveNext , antes de que el enumerador produjera "mundo", se ejecutó algún código dentro del enumerador. Lo que esto significa es que en el Enumerador, podemos escribir código que se ejecuta hasta que llegue a una declaración de yield return , luego simplemente hacer una pausa hasta que alguien llame a MoveNext (fácilmente con todos los estados / variables cuidadosamente capturados, para que podamos continuar donde lo dejamos) . Después de una llamada MoveNext , el siguiente bit de código después de la declaración de yield return puede ejecutarse hasta que se alcance otro yield return . Así que ahora podemos controlar la ejecución del código entre las declaraciones de yield return con la llamada MoveNext al Enumerador.

Ahora, digamos que en lugar de generar cadenas, nuestro Enumerador debía mostrar un mensaje que dice al interlocutor de MoveNext , "por favor, espere unos segundos (en el tiempo de espera) antes de volver a llamar a MoveNext " . La persona que llama está escrita para "entender" una variedad de mensajes. Estos mensajes siempre estarán en la línea de "espere a que esto suceda antes de volver a llamar a MoveNext " .

Ahora tenemos un medio poderoso para pausar y reiniciar el código que requiere que se cumplan otras condiciones antes de que pueda continuar, sin tener que escribir esa funcionalidad en otro método, como hacer cosas asíncronas sin las rutinas. Sin las rutinas, tiene fuerzas para pasar por un horrible objeto de estado asíncrono que tendría que ensamblar manualmente para capturar el estado entre el final de un método y el inicio de otro después de algunas cosas asíncronas). Coroutines elimina esto porque el alcance se conserva (mediante la magia del compilador), por lo que las variables locales persisten durante las tareas asíncronas de larga duración.

StartCoroutine simplemente inicia todo el proceso. Llama a MoveNext en el Enumerador ... algunos códigos se ejecutan en el Enumerador ... El enumerador muestra un mensaje de control, que informa al código en StartCoroutine cuando debe volver a llamar a MoveNext . Esto no tiene por qué ocurrir en un nuevo subproceso, pero puede ser útil en escenarios de subprocesos múltiples porque podemos llamar a MoveNext desde diferentes subprocesos y controlar dónde se realiza el trabajo.