Est coroutine un nouveau thread dans Unity3D?

Je suis confus et curieux de savoir comment coroutines (dans Unity3D et peut-être d'autres endroits). Est coroutine un nouveau thread? L'unité de la documentation ils ont dit:

Une coroutine est une fonction qui permet de suspendre son exécution (le rendement) jusqu'à ce que le YieldInstruction finitions.

Et ils ont C# exemples ici:

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);
    }
}

J'ai beaucoup de questions à propos de cet exemple:

  1. Dans l'exemple ci-dessus, qui est la coroutine? Est WaitAndPrint() une coroutine? Est WaitForSeconds() une coroutine?

  2. Dans cette ligne: yield return new WaitForSeconds(waitTime);, pourquoi les deux yield et return sont présents? J'ai lu dans L'unité de documentation que "L'instruction rendement est un type spécial de retour, qui assure que la fonction va continuer à partir de la ligne après l'instruction rendement prochaine fois qu'il est appelé." Si yield est un spécial return, qu'est-ce que return fais ici?

  3. Pourquoi devons-nous retourner un IEnumerator?

  4. Ne StartCoroutine démarrer un nouveau thread?

  5. Combien de fois a WaitAndPrint() été appelé dans l'exemple ci-dessus? Ne yield return new WaitForSeconds(waitTime); vraiment de retour? Si oui, alors je suppose que WaitAndPrint() a été appelé à deux reprises dans le code ci-dessus. Et je suppose que StartCoroutine() appelait WaitAndPrint() plusieurs fois. Cependant, j'ai vu une autre Unité de la documentation qui dit: "L'exécution d'une coroutine peut être interrompue à tout moment à l'aide de l'instruction rendement. Le rendement de la valeur de retour indique quand la coroutine est la reprise." Ces mots me font sentir que WaitAndPrint() en réalité n'a pas retourné; il s'agissait simplement d'une pause; il a été en attente pour WaitForSeconds() de retour. Si c'est le cas, dans le code ci-dessus WaitAndPrint() a été appelé qu'une seule fois, et StartCoroutine était seulement responsable pour le démarrage de la fonction, non pas de l'appeler plusieurs fois.

En réponse à la question dans le titre, le coroutines NE PAS démarrer un nouveau thread et en eux-mêmes n'ont pas de connexion à fils. N'oubliez pas que Unity3D est fondamentalement cadre de base .. MonoBehaviours sont un cadre basé sur le concept. Coroutines - dans l'Unité - sont intrinsèquement liées à ce changement de paradigme. Les Threads sont totalement étranger.
Je tombe sur ce tuto unitygeek.com/coroutines-in-unity3d/,It explique très bien au sujet de l'utilisation de coroutines dans unity3d

OriginalL'auteur CherryQu | 2013-06-06

  1. 20

    Coroutines sont une technique extrêmement puissante utilisé pour émuler les types de fonctionnalités prises en charge par l'async/await .net4.5, mais dans les versions antérieures ( c# >= v2.0 ) .

    Microsoft CCR (lire) emploie également (salariés?) cette approche.

    Nous allons faire une chose hors de la voie. yield seul n'est pas valide et est toujours suivi par return ou break.

    Penser à une norme IEnumerator (qui ne donne pas de flux de messages de contrôle).

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

    Maintenant:

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

    Quel est le résultat?

    bonjour 
foo! 
monde

    Notez comment, la deuxième fois que nous avons appelé MoveNext, avant de l'agent Recenseur a donné "le monde" du code a couru à l'intérieur de l'agent Recenseur. Ce que cela signifie est que, dans l'Énumérateur, nous pouvons écrire le code qui s'exécute jusqu'à ce qu'il frappe une yield return déclaration, puis il suffit de s'interrompt jusqu'à ce que quelqu'un appelle MoveNext (idéalement avec tous les/les variables parfaitement capturé, afin que nous puissions reprendre là où nous nous sommes quittés). Après un MoveNext appel, le bit suivant de code après le yield return instruction peut courir jusqu'à l'autre yield return est atteint. Nous pouvons donc contrôler l'exécution du code entre les yield return déclarations avec les MoveNext appel à l'agent Recenseur.

    Maintenant, dire au lieu de céder à cordes, notre agent Recenseur donnent un message qui dit à l'appelant de MoveNext, "s'il vous plaît traîner pour x (waitTime) secondes avant d'appeler MoveNext nouveau". L'appelant est écrit à "comprendre" une variété de messages. Ces messages seront toujours le long de la lignes de "s'il vous plaît attendre pour tels et tels pour arriver avant l'appel de MoveNext nouveau".

    Maintenant, nous avons un puissant moyen d'arrêter et de redémarrer le code qui exige d'autres conditions à remplir avant de procéder, sans avoir à écrire cette fonctionnalité dans une autre méthode, comme faire async des trucs sans coroutines. Sans coroutines, vous êtes forces de passer autour d'un horrible état asynchrone objets que vous devrez assembler manuellement à l'état de capture entre la fin d'une méthode et le départ de l'autre après quelques async genre de trucs). Coroutines éliminer ce parce que la portée est préservée (par le compilateur de la magie), de sorte que vos variables locales persistent plus longtemps vécu async choses.

    StartCoroutine commence simplement l'ensemble du processus. Il appelle MoveNext sur l'Énumérateur... un peu de code s'exécute dans l'Énumérateur... L'agent recenseur donne un message de contrôle, qui en informe le code dans StartCoroutine quand appeler MoveNext de nouveau. Cela ne doit pas arriver dans un nouveau Thread, mais peut être pratique dans multithread scénarios parce que nous pouvons appeler MoveNext de différents threads et de contrôle où est effectué le travail.

    Et pour les autres, Unité de l'ordonnance d'exécution de la page montrant coroutines courir après mise à Jour().

    OriginalL'auteur spender