C#yield return和yield break函数执行逻辑理解

来源：互联网发布：android网络抓包工具编辑：程序博客网时间：2024/05/22 03:23

1.使用要求：

1）你不能在具有以下特点的方法中包含 yield return 或 yield break 语句：
匿名方法。有关详细信息，请参阅匿名方法（C# 编程指南）。

包含不安全的块的方法。有关详细信息，请参阅unsafe（C# 参考）。

2）返回类型要求：
迭代器的声明必须满足以下要求：
    返回类型必须为 IEnumerable、IEnumerable<T>、IEnumerator 或 IEnumerator<T>。
    该声明不能有任何 ref 或out https://msdn.microsoft.com/zh-cn/library/t3c3bfhx.aspx 参数。
    返回 IEnumerable 或 IEnumerator 的迭代器的 yield 类型为 object。
    如果迭代器返回 IEnumerable<T> 或 IEnumerator<T>，则必须将 yield return 语句中的表达式类型隐式转换为泛型类型参数。

3）异常处理：
不能将 yield return 语句置于 try-catch 块中。可将 yield return 语句置于 try-finally 语句的 try 块中。
yield break 语句可以位于 try 块或 catch 块，但不能位于 finally 块。
如果 foreach 主体（在迭代器方法之外）引发异常，则将执行迭代器方法中的 finally 块。

2.yield return 要求指定返回类型和查询完交出控制权保留堆栈信息

1.返回类型，查询内部，用于查询返回一个，不是一次函数执行到底提高了线性遍历性能
// 返回Oject没有什么作用
//Object enum_Num = Power(2, 8);
//Console.Write("{0} ", enum_Num);

// 返回IEnumerable<T>默认给创建一个迭代器容器,返回时候要隐式转换为泛型具体类型，且外部遍历也要foreach驱动，因为里面只取一个返回。

3.yield break 会不等整个查询元素遍历完而返回，可以限定返回值区间

4.直接调用yield封装的函数不会被执行，只是创建一个迭代器集合，会延迟到使用时候计算

MSDN中解释：
调用 MyIteratorMethod 并不执行该方法的主体。相反，该调用会将 IEnumerable<string> 返回到 elements 变量中。

在 foreach 循环迭代时，将为 elements 调用 MoveNext 方法。此调用将执行 MyIteratorMethod 的主体，直至到达下一个 yield return 语句。 yield return 语句返回的表达式不仅决定了循环体使用的 element 变量值，还决定了元素的 Current 属性（它是 IEnumerable<string>）。

在 foreach 循环的每个后续迭代中，迭代器主体的执行将从它暂停的位置继续，直至到达 yield return 语句后才会停止。在到达迭代器方法的结尾或 yield break 语句时，foreach 循环便已完成。

5.yield return 和yield break在异步循环调用中优势,unity中的协程刚好也使用了

执行一次会将控制权从函数里面交出，给外部，如果外部是异步的或者子线程一直循环的被挂起了，下次再重入该函数，那么该yield函数的调用堆栈状态会被保留，从而接着上次状态继续执行。

6. 如果yield迭代器全部执行完了，那么不会保留堆栈信息，例如没有协程就不会

再重新进来不会保留堆栈信息，也就和一般迭代集合返回一样了。

7.yield语句和foreach语句，都是会根据当前操作的迭代器，CRL为它生成相应的枚举属性和枚举方法，yield有状态

foreach语句
C#中的foreach语句不会翻译为IL中的foreach语句，而是会翻译为IEnumerable中的接口的属性和函数，将类型替换为相应的泛型，IEnumerator<T> while MoveNext Current语句，会用while一次遍历迭代器的所有元素。foreach语句会调用类型的GetEnumerator方法。
yield语句也是一个迭代块，必须声明返回值类型为IEnumerable、IEnumerable<T>、IEnumerator<T>、IEnumerator类型。yield语句会生成一个枚举器IEnumerator，CRL翻译为Switch语句的MoveNext、Current语句、State保持当前的语句下一个索引状态的状态迭代器，下次重入的时候就从迭代器的下一个索引取数据并置下一个状态，就马上返回，就是一个很简单程序设置没有什么高级的分段执行机制，在异步线程或者协程事件回调中才会赋予它保留现场继续执行的强大能力。

验证实例代码：

  public class PowersOf2    {        static void Main()        {            // 1.返回类型，用于查询返回一个，不是一次函数执行到底提高了线性遍历性能            // 返回Oject没有什么作用            //Object enum_Num = Power(2, 8);            //Console.Write("{0} ", enum_Num);            // 返回IEnumerable<T>,返回时候要隐式转换为泛型具体类型，且外部遍历也要foreach驱动，因为里面只取一个返回。            //Display powers of 2 up to the exponent of 8:            // 2.yield break 会不等全部遍历完而返回，可以限定返回值区间            bool bFind = false;            int nFindValueExist = 64;            foreach (int i in Power(2, 8))            {                // 查询存在                if (i == nFindValueExist)                {                    bFind = true;                    break;                }                if( i == 2 )                {                    break;                }            }            foreach (int i in Power(2, 8))            {                // 查询存在                if (i == nFindValueExist)                {                    bFind = true;                    break;                }            }            if( bFind )            {                Console.Write("Find {0} OK", nFindValueExist);            }            else            {                Console.Write("Find {0} Failed", nFindValueExist);            }        }        public static IEnumerable Power(int number, int exponent)//<int>        {            int result = 1;            for (int i = 0; i <= exponent; i++)            {                if (i == 0)                {                    yield return result;                }                else if( i < 5 )                {                    result = result * number;                    yield return result;                }                else                {                    yield break;                }            }        }        // Output: 1 2 4 8 16 32 64 128 256    }

验证代码片段2：

using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace TestYield{    class Program    {        static IEnumerable<int> WithNoYield()        {            IList<int> list = new List<int>();            for (int i = 0; i < 20; i++)            {                Console.WriteLine("Quary " + i.ToString());                if (i > 2)                    list.Add(i);            }            return list;        }        static IEnumerable<int> WithYield()        {            for (int i = 0; i < 20; i++)            {                Console.WriteLine("Quary " + i.ToString());                if (i > 2)                    yield return i;            }        }        static void Main(string[] args)        {            Console.WriteLine("------------------ WithNoYield--------------");            WithNoYield();            Console.WriteLine("------------------WithYield--------------");            // 直接调用yield封装的函数不会被执行，会延迟计算            WithYield();            WithYield();            WithYield();            WithYield();            WithYield();            WithYield();                       // 执行一次会将控制权从函数里面交出，给外部，如果外部是异步的或者子线程一直循环的被挂起了            // 下次再重入该函数，那么该yield函数的调用堆栈状态会被保留，从而接着上次状态继续执行            Console.WriteLine("------------------ foreach WithNoYield--------------");            foreach (int i in WithNoYield())            {                Console.WriteLine("Result " + i.ToString());            }            // 如果yield迭代器全部执行完了，再重新进来不会保留堆栈信息            Console.WriteLine("------------------ foreach WithYield1--------------");            foreach (int i in WithYield())            {                Console.WriteLine("Result " + i.ToString());                if( i == 10 )                {                    break;                }            }            Console.WriteLine("------------------ foreach WithYield2-------------");            foreach (int i in WithYield())            {                Console.WriteLine("Result " + i.ToString());            }            Console.ReadLine();        }    }}

yield语句和foreach语句的枚举访问器展开特性验证：

using System;using System.Collections;using System.Linq;using System.Text;namespace Wrox.ProCSharp.Arrays{    public class GameMoves    {       // 两个迭代器，每个都有自己的While,Current, MoveNext调用迭代器自己，yield语句还会导致记录迭代器state状态。        private IEnumerator cross;        private IEnumerator circle;        public GameMoves()        {            // 迭代器就是一个返回枚举集合的方法，这里已经声明了，这里两个是固定的只是外部的会切换            cross = Cross2();            circle = Circle();        }        private int move = 0;        const int MaxMoves = 9;        // 迭代器MoveNext会进来这里，也就是进来迭代器本身遍历获取对象        public IEnumerator Cross2()        {            while (true)            {                Console.WriteLine("Cross, move {0}", move);                if (++move >= MaxMoves)                    yield break;                yield return circle;            }        }        public IEnumerator Circle()        {            while (true)            {                Console.WriteLine("Circle, move {0}", move);                if (++move >= MaxMoves)                    yield break;                yield return cross;            }        }    }}

foreach,yield调用端：

static void Main()        {            // 只是声明不会调用            var game = new GameMoves();            // 外部的迭代器类型声明为Cross2，声明时候只是声明不会调用            IEnumerator enumerator = game.Cross2();            // 会进入枚举器            // 只是调用当前迭代器，当前迭代器返回值赋值给了当前的enumerator.Current，值是另外一个迭代器            while (enumerator.MoveNext())            {                // 用另外迭代器换掉当前迭代器                enumerator = enumerator.Current as IEnumerator;            }        }

0 0