Unity协程的yield & C#的yield关键字

https://blog.csdn.net/qq_33337811/article/details/73608891?utm_source=blogxgwz0

https://blog.csdn.net/jinxiul5/article/details/82114407?utm_source=blogxgwz0

Unity协程的yield & C#的yield关键字

1.Unity协程：

这里说的是Unity中通过StartCoroutine开启IEnumerator协程里的yield相关：

1.yield return 0、yield return null

等待下一帧接着执行下面的内容

2.yield return new WaitForSeconds(float secs)

等待指定秒数，接着执行下面的内容

3.yield return www;

使用WWW下载，等待www下载完成以后再执行下面代码

WWW www=new WWW("这里是地址");
Debug.Log("1");
yield return www; //这里等待www.isDone，也就是下载完成以后才会走后面的代码
Debug.Log("2");

4.yield return StartCoroutine("协程方法名")

先执行协程方法，并等待，直到该协程方法执行完再执行后面的内容

5.yield break

退出协程，不执行break后面的代码

例：

public static bool temp = true;
    private void Start()
    {
        StartCoroutine(ForExample());
    }
    public IEnumerator ForExample()
    {
        yield return "1";  // 挂起等待下一帧
        Debug.Log("hiha1");
        yield return "2";  // 挂起等待下一帧
  
        Debug.Log("hiha2");
        if (temp)              
        {
            // 执行 yield break 之后不再执行下面语句  
            Debug.Log("bareak");
            yield break;
        }
        // 否则,temp为 false  
        yield return "3";   
        Debug.Log("hiha3");
        yield return "4";  
        Debug.Log("hiha4");
    }
结果：
hiha1
hiha2
bareak

///

2.C# yield：  (参考链接：http://www.cnblogs.com/vivid-stanley/p/5272736.html)
yield 是在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。它的形式为下列之一：
yield return <expression>;
yield break

e.g.

class CustomCollection : IEnumerable
    {
        static void Main()
        {
            CustomCollection cc = new CustomCollection();
           foreach (String word in cc)
            {
               Console.WriteLine("Info:" + word);
            }
        }
        public IEnumerator GetEnumerator()
        {
            yield return "T1";
            yield return "T2";
            yield return "T3";
            yield return "T4";
        }
    }
上面的例子是实现了一个自定义的迭代器；实现可迭代（可以用foreach）的数据集合，必须实现GetEmumerator()方法，返回实现了IEmumerator的对象实例。

完成这个， 有两种方法：
1/ 一种是：上面这样用yield return. yield return 需要配合IEmumerator进行使用， 在外部foreach循环中，它会执行GetEmumerator()方法，遇到yield return, 做了如下两件事情：

1.记录下当前执行到的代码位置；

2. 将代码控制权返回到外部， yield return 后面的值， 作为迭代的当前值。

当执行下一个循环， 从刚才记录的代码位置后面， 开始继续执行代码。

简单地说， yield return 就是实现IEmumerator的超级简化版， 是不是很简单？

2/ 另一种是：实现IEmumerator版本：

 public class HelloBoyGirls : IEnumerator
    {
        private int cusor = -1;
        private String[] words = {"T1", "T2", "T3", "T4"};
        
        public bool MoveNext ()
        {
            cusor++;
            return cusor < words.Length;
       }
 
       public void Reset ()
       {
            cusor = 0;
        }
       public object Current {
            get {
                return words [cusor];
            }
        }
    }
    class CustomCollection : IEnumerable
    {
        static void Main()
        {
            CustomCollection cc = new CustomCollection();
            foreach (String word in cc)
            {
                Console.WriteLine("Info:" + word);
            }
        }
        public IEnumerator GetEnumerator()
        {
            return new HelloBoyGirls();
        }
    }
结果都是：
Info:T1
Info:T2
Info:T3
Info:T4

那么问题又来了， yield return 是如何决定循环该结束，yield return 之后的代码， 什么时候执行呢？

把上面的例子改造一下， 不要用方便的foreach了， 用while 循环自己控制：
public class CustomCollection : IEnumerable
    {
        public IEnumerator GetEnumerator()
        {
            yield return "T1";
            yield return "T2";
            yield return "T3";
            yield return "T4";
            Console.WriteLine("After all yield returns.");
        }
        public static void Main(string[] args)
         {
             CustomCollection cc = new CustomCollection();
 
             IEnumerator enumerator = cc.GetEnumerator();
             while (true) {
                 bool canMoveNext = enumerator.MoveNext();
                 Console.WriteLine("canMoveNext:" +canMoveNext);
                 if (!canMoveNext)
                    break;
                 Object obj = enumerator.Current;
                 Console.WriteLine("current obj:" +obj);
             }
 //            foreach (String word in cc) {
 //                Console.WriteLine ("word:" +word);
 //            }
             Console.WriteLine("Main End.");
 
        }
    }
结果：
canMoveNext:True
current obj:Hello
canMoveNext:True
current obj:Boys
canMoveNext:True
current obj:And
canMoveNext:True
current obj:Girls
After all yield returns.
canMoveNext:False
Main End.
说明C#里，每次调用MoveNext()，走到下一个yield处(从第一个开始，先走第一个)，然后Current值就是yield return后面的值，遇到yield再停住，直到再次调用；如果没有找到下一个yield则MoveNext()返回false。
除了yield return, 还有yield break; yield break 的作用是， 停止循环， MoveNext()为false， yield break 之后的语句， 不会被执行！

什么是协程

协程在当前主程序运行时,开启另一段逻辑处理,协程主要用于代码等待

注意事项: ##<协程的方法名最前面最好加上大写的IE表示这是一个协程>

如果协程中有嵌套协程的时候,关闭当前协程不会影响嵌套的协程,.只会关闭当前协程,嵌套协程继续执行 
1.协程所在脚本关闭的时候协程不会停止,但是协程所在的游戏对象删除的时候协程将会被系统回收 
2.关于协程的关闭,下面会详解 
3.协程的返回值必须是IEnumerator 
4.协程的内部必须体验Yield return 值 
5.协程可以重载 
6.协程可以多次调用,但是不可以关闭后继续运行,只能重新开启协程 
7.协程可以嵌套 
8.协程的参数不能使用ref 和out 修饰 
9.协程在执行完内部所有代码的时候会退出协程

关于协程yield return 后面的值

yiled return 0; 0可以换成任意的int类型的值,都是当前暂停一帧,从下一帧开始执行
yiled return 协程,yiled return 后面可以跟一个协程,当执行到该行代码的时候执行yiled return 后面的协程,如果下面还有代码在执行完该协程的时候,回来继续执行.
yiled return 后面可以跟一个WWW类,当下载完成该WWW类的时候,继续向下面的代码执行
yiled return new WaitForSeconds(时间),时间可以随意设置,该方法主要作用是等待几秒钟后执行,yiled return 后面的代码;
yiled return 后面可以跟一个类,等等根据自己的需要进行使用
开启协程和关闭协程

1.直接使用协程方法名 
开启协程 StartCoroutine(“协程方法名 “); 
关闭协程 StopCoroutine(“协程方法名 “); 
2.使用协程方法名加参数 
开启协程 StartCoroutine(“协程方法名”,参数);<该方法只适用于协程只有一个参数的时候> 
关闭协程 StopCoroutine(“协程方法名”); 
3.使用方法 
开启协程 StartCoroutine(协程方法名(参数));<该方法中的参数个数随意 
关闭协程 StopCoroutine(协程方法名(参数));<该方法不能关闭该协程,但是开启可以使用>

使用方法参数正确开启关闭协程: 
<1>定义一个IEnumerator 类型的全局变量StopIE 
public IEnumerator StopIE; 
<2>接收 协程方法名(参数) 
StopIE = 协程方法名(参数); 
<3>开启协程 
在这里开启协程可以直接用变量代替方法名加参数 
StartCoroutine(StopIE); 
<4>关闭协程 
在这里同样 
StopCoroutine(StopIE);

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class StrIEScript : MonoBehaviour {
    //定义变量存储协程
    IEnumerator MoveTarget;
    void Start () {
        MoveTarget = IEMove (transform,2f,20f);
        //通过变量开启协程
        StartCoroutine (MoveTarget);
    }

    private void Update()
    {
        //按下鼠标左键的时候关闭协程
        if (Input.GetMouseButtonDown(0))
        {
            //通过变量关闭协程
            StopCoroutine ( MoveTarget );
        }
    }
    //该协程用于向目标物体的正前方移动,_t秒移动一次,移动速度_speed
    IEnumerator IEMove(Transform _target,float _t,float _speed)
    {

        //协程嵌套,开启协程
        StartCoroutine ("IERotate",5f);
        //改协程除非手动关闭否则将会永远存在,因为存在死循环,协程内部代码未执行完毕,系统不会回收协程
        while (true)
        {
            yield return new WaitForSeconds (_t);
            _target.Translate (_target.forward*Time.deltaTime*_speed);
        }

    }
    //围绕自身的Y轴旋转_t秒
    IEnumerator IERotate(float _t)
    {
        float _timer = 0;
        while (_timer<_t)
        {
            yield return 0;
            transform .Rotate (transform .up,100f*Time.deltaTime);
            _timer += Time.deltaTime;

        }

    }
}