前段时间了解到yield关键字，一直觉得还不错。今天给大家分享一下yield关键字的用法。yield return 返回集合不是一次性返回所有集合元素，而是一次调用返回一个元素。具体如何使用yield return 返回集合呢？我们一起往下面看吧。

yield return 和yield break：

我们看下平常循环返回集合的使用操作（返回1-100中的偶数）：

  1.   class Program
  2.     {
  3.         static private List<int> _numArray; //用来保存1-100 这100个整数
  5.         Program() //构造函数。我们可以通过这个构造函数往待测试集合中存入1-100这100个测试数据
  6.         {
  7.             _numArray = new List<int>(); //给集合变量开始在堆内存上开内存，并且把内存首地址交给这个_numArray变量
  8.  
  9.             for (int i = 1; i <= 100; i++)
  10.             {
  11.                 _numArray.Add(i);  //把1到100保存在集合当中方便操作
  12.             }
  13.         }
  15.         static void Main(string[] args)
  16.         {
  17.             new Program();
  19.             TestMethod();
  22.         }
  24.         //测试求1到100之间的全部偶数
  25.         static public void TestMethod()
  26.         {
  27.             foreach (var item in GetAllEvenNumberOld())
  28.             {
  29.                 Console.WriteLine(item); //输出偶数测试
  30.             }
  31.         }
  33.         /// <summary>
  34.         /// 使用平常返回集合方法
  35.         /// </summary>
  36.         /// <returns></returns>
  37.         static IEnumerable<int> GetAllEvenNumberOld()
  38.         {
  39.             var listNum = new List<int>();
  40.             foreach (int num in _numArray)
  41.             {
  42.                 if (num % 2 == 0) //判断是不是偶数
  43.                 {
  44.                     listNum.Add(num); //返回当前偶数
  46.                 }
  47.             }
  48.             return listNum;
  49.         } 
  50.     }

 

然后我们再看看使用yield return返回集合操作：

  1.  class Program
  2.     {
  3.         static private List<int> _numArray; //用来保存1-100 这100个整数
  5.         Program() //构造函数。我们可以通过这个构造函数往待测试集合中存入1-100这100个测试数据
  6.         {
  7.             _numArray = new List<int>(); //给集合变量开始在堆内存上开内存，并且把内存首地址交给这个_numArray变量
  8.  
  9.             for (int i = 1; i <= 100; i++)
  10.             {
  11.                 _numArray.Add(i);  //把1到100保存在集合当中方便操作
  12.             }
  13.         }
  15.         static void Main(string[] args)
  16.         {
  17.             new Program();
  19.             TestMethod();
  22.         }
  24.         //测试求1到100之间的全部偶数
  25.         static public void TestMethod()
  26.         {
  27.             foreach (var item in GetAllEvenNumber())
  28.             {
  29.                 Console.WriteLine(item); //输出偶数测试
  30.             }
  31.         }  
  33.         //使用Yield Return情况下的方法
  34.         static IEnumerable<int> GetAllEvenNumber()
  35.         {
  37.             foreach (int num in _numArray)
  38.             {
  39.                 if (num % 2 == 0) //判断是不是偶数
  40.                 {
  41.                     yield return num; //返回当前偶数
  43.                 }
  44.             }
  45.             yield break;  //当前集合已经遍历完毕，我们就跳出当前函数，其实你不加也可以
  46.             //这个作用就是提前结束当前函数，就是说这个函数运行完毕了。
  47.         }
  50.     }

 

上面我们看到了yield return 的使用方法，那么这个与return返回集合有什么区别呢？我们看下面一个案例来进行分析：

我们首先先看通过returun返回集合的一个案例：

  1.     class Program
  2.     { 
  3.         static void Main(string[] args)
  4.         {
  5.             foreach (var item in GetNums())
  6.             {
  7.                 Console.WriteLine($"  common return:{item}");
  8.             }
  9.         } 
  11.         /// <summary>
  12.         /// 平常return 返回集合
  13.         /// </summary>
  14.         /// <returns></returns>
  15.         public static IEnumerable<int> GetNums()
  16.         {
  17.             var listNum = new List<int>();
  18.             for (int i = 0; i < 10; i++)
  19.             {
  20.                 Console.WriteLine($"yield return:{i}");
  21.                 listNum.Add(i);
  22.             }
  23.             return listNum;
  24.         }
  27.     }

通过代码的运行结果，我们可以看到这里返回的结果 yield return 和comment return是分成两边的。先执行完一个然后开始执行另外一个。不干涉。

我们接着看下使用yield return返回集合：

  1.     class Program
  2.     { 
  3.         static void Main(string[] args)
  4.         {
  5.             foreach (var item in GetNumsYield())
  6.             {
  7.                 Console.WriteLine($"  common return:{item}");
  8.             }
  9.         }
  11.         /// <summary>
  12.         /// 通过yield return 返回集合
  13.         /// </summary>
  14.         /// <returns></returns>
  15.         public static IEnumerable<int> GetNumsYield()
  16.         {
  17.             for (int i = 0; i < 10; i++)
  18.             {
  19.                 Console.WriteLine($"yield return:{i}");
  20.                 yield return i;
  21.             }
  22.         } 
  23.     }

我们看这个运行结果，这里yield return 和comment return 的输出完全交替了。这里说明是一次调用就返回了一个元素。

通过上面的案例我们可以发现，yield return 并不是等所有执行完了才一次性返回的。而是调用一次就返回一次结果的元素。这也就是按需供给。

我们已经大致了解了yield 的用法和它与平常的返回的区别。我们可以继续查看其运行原理。我们首先看这么一个案例（在0-10中随机返回五个数字）：

我们通过SharpLab反编译其代码,我们进行查看发现yield具体详细实现：

 

我们看到yield内部含有一个迭代器。这样去实现的迭代遍历。同时包含_state字段、用来存储上一次的记录。_current包含当前的值、也通过_initialThreadId获取当前线程id。其中主要的方法是迭代器方法MoveNext()。我们根据反编译结果来实现一个与yiled相似的类：

 

  1.     /// <summary>
  2.     /// 解析yield并定义相似类
  3.     /// </summary>
  4.     public sealed class GetRandomNumbersClass : IEnumerable<int>, IEnumerable, IEnumerator<int>, IDisposable, IEnumerator
  5.     {
  6.         public static Random r = new Random();
  8.         /// <summary>
  9.         /// 状态
  10.         /// </summary>
  11.         private int _state;
  13.         /// <summary>
  14.         ///储存当前值
  15.         /// </summary>
  16.         private int _current;
  18.         /// <summary>
  19.         /// 线程id
  20.         /// </summary>
  21.         private int _initialThreadId;
  23.         /// <summary>
  24.         /// 集合元素数量
  25.         /// </summary>
  26.         private int count;
  28.         /// <summary>
  29.         /// 集合元素数量
  30.         /// </summary>
  31.         public int _count;
  33.         /// <summary>
  34.         /// 当前指针
  35.         /// </summary>
  36.         private int i;
  38.         int IEnumerator<int>.Current
  39.         {
  40.             [DebuggerHidden]
  41.             get
  42.             {
  43.                 return _current;
  44.             }
  45.         }
  47.         object IEnumerator.Current
  48.         {
  49.             [DebuggerHidden]
  50.             get
  51.             {
  52.                 return _current;
  53.             }
  54.         }
  56.         [DebuggerHidden]
  57.         public GetRandomNumbersClass(int state)
  58.         {
  59.             this._state = state;
  60.             _initialThreadId = Environment.CurrentManagedThreadId;
  61.         }
  63.         [DebuggerHidden]
  64.         void IDisposable.Dispose()
  65.         {
  66.         }
  68.         private bool MoveNext()
  69.         {
  70.             switch (_state)
  71.             {
  72.                 default:
  73.                     return false;
  74.                 case 0:
  75.                     _state = -1;
  76.                     i = 0;
  77.                     break;
  78.                 case 1:
  79.                     _state = -1;
  80.                     i++;
  81.                     break;
  82.             }
  83.             if (i < count)
  84.             {
  85.                 _current = r.Next(10);
  86.                 _state = 1;
  87.                 return true;
  88.             }
  89.             return false;
  90.         }
  92.         bool IEnumerator.MoveNext()
  93.         {
  94.             //ILSpy generated this explicit interface implementation from .override directive in MoveNext
  95.             return this.MoveNext();
  96.         }
  98.         [DebuggerHidden]
  99.         void IEnumerator.Reset()
  100.         {
  101.             throw new NotSupportedException();
  102.         }
  104.         [DebuggerHidden]
  105.         public IEnumerator<int> GetEnumerator()
  106.         {
  107.             GetRandomNumbersClass _getRandom;
  108.             if (_state == -2 && _initialThreadId == Environment.CurrentManagedThreadId)
  109.             {
  110.                 _state = 0;
  111.                 _getRandom = this;
  112.             }
  113.             else
  114.             {
  115.                 _getRandom = new GetRandomNumbersClass(0);
  116.             }
  117.             _getRandom.count = _count;
  118.             return _getRandom;
  119.         }
  121.         [DebuggerHidden]
  122.         IEnumerator IEnumerable.GetEnumerator()
  123.         {
  124.             return GetEnumerator();
  125.         }
  128.         [IteratorStateMachine(typeof(GetRandomNumbersClass))]
  129.         private static IEnumerable<int> GetList(int count)
  130.         {
  131.             GetRandomNumbersClass getRandomNumbersClass = new GetRandomNumbersClass(-2);
  132.             getRandomNumbersClass._count = count;
  133.             return getRandomNumbersClass;
  134.         }
  135.         private static void Main(string[] args)
  136.         {
  137.             IEnumerator<int> enumerator = GetList(5).GetEnumerator();
  138.             try
  139.             {
  140.                 foreach (int item in GetList(5))
  141.                     Console.WriteLine(item);
  142.                 //while (enumerator.MoveNext())
  143.                 //{
  144.                 //    int current = enumerator.Current;
  145.                 //    Console.WriteLine(current);
  146.                 //}
  147.             }
  148.             finally
  149.             {
  150.                 if (enumerator != null)
  151.                 {
  152.                     enumerator.Dispose();
  153.                 }
  154.             }
  155.             Console.ReadKey();
  156.         }
  157.     }

 

　

 

　用爱生活，你会使自己幸福！用爱工作，你会使很多人幸福！ 

   欢迎大家扫描下方二维码，和我一起学习更多的知识

版权声明：本文为hulizhong原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/hulizhong/p/11763956.html