关于C#中yield关键字的深入解析

前言

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

yield使用介绍

yield return 和yield break：

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

 class program
 {
 static private list<int> _numarray; //用来保存1-100 这100个整数

 program() //构造函数。我们可以通过这个构造函数往待测试集合中存入1-100这100个测试数据
 {
  _numarray = new list<int>(); //给集合变量开始在堆内存上开内存，并且把内存首地址交给这个_numarray变量

  for (int i = 1; i <= 100; i++)
  {
  _numarray.add(i); //把1到100保存在集合当中方便操作
  }
 }

 static void main(string[] args)
 {
  new program();

  testmethod();


 }

 //测试求1到100之间的全部偶数
 static public void testmethod()
 {
  foreach (var item in getallevennumberold())
  {
  console.writeline(item); //输出偶数测试
  }
 }

 /// <summary>
 /// 使用平常返回集合方法
 /// </summary>
 /// <returns></returns>
 static ienumerable<int> getallevennumberold()
 {
  var listnum = new list<int>();
  foreach (int num in _numarray)
  {
  if (num % 2 == 0) //判断是不是偶数
  {
   listnum.add(num); //返回当前偶数

  }
  }
  return listnum;
 } 
 }

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

 class program
 {
 static private list<int> _numarray; //用来保存1-100 这100个整数

 program() //构造函数。我们可以通过这个构造函数往待测试集合中存入1-100这100个测试数据
 {
  _numarray = new list<int>(); //给集合变量开始在堆内存上开内存，并且把内存首地址交给这个_numarray变量

  for (int i = 1; i <= 100; i++)
  {
  _numarray.add(i); //把1到100保存在集合当中方便操作
  }
 }

 static void main(string[] args)
 {
  new program();

  testmethod();


 }

 //测试求1到100之间的全部偶数
 static public void testmethod()
 {
  foreach (var item in getallevennumber())
  {
  console.writeline(item); //输出偶数测试
  }
 } 

 //使用yield return情况下的方法
 static ienumerable<int> getallevennumber()
 {

  foreach (int num in _numarray)
  {
  if (num % 2 == 0) //判断是不是偶数
  {
   yield return num; //返回当前偶数

  }
  }
  yield break; //当前集合已经遍历完毕，我们就跳出当前函数，其实你不加也可以
  //这个作用就是提前结束当前函数，就是说这个函数运行完毕了。
 }


 }

与平常return比较

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

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

 class program
 { 
 static void main(string[] args)
 {
  foreach (var item in getnums())
  {
  console.writeline($" common return:{item}");
  }
 } 

 /// <summary>
 /// 平常return 返回集合
 /// </summary>
 /// <returns></returns>
 public static ienumerable<int> getnums()
 {
  var listnum = new list<int>();
  for (int i = 0; i < 10; i++)
  {
  console.writeline($"yield return:{i}");
  listnum.add(i);
  }
  return listnum;
 }
 }

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

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

 class program
 { 
 static void main(string[] args)
 {
  foreach (var item in getnumsyield())
  {
  console.writeline($" common return:{item}");
  }
 }

 /// <summary>
 /// 通过yield return 返回集合
 /// </summary>
 /// <returns></returns>
 public static ienumerable<int> getnumsyield()
 {
  for (int i = 0; i < 10; i++)
  {
  console.writeline($"yield return:{i}");
  yield return i;
  }
 } 
 }

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

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

解析定义类

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

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

 

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

 /// <summary>
 /// 解析yield并定义相似类
 /// </summary>
 public sealed class getrandomnumbersclass : ienumerable<int>, ienumerable, ienumerator<int>, idisposable, ienumerator
 {
  public static random r = new random();

  /// <summary>
  /// 状态
  /// </summary>
  private int _state;

  /// <summary>
  ///储存当前值
  /// </summary>
  private int _current;

  /// <summary>
  /// 线程id
  /// </summary>
  private int _initialthreadid;

  /// <summary>
  /// 集合元素数量
  /// </summary>
  private int count;

  /// <summary>
  /// 集合元素数量
  /// </summary>
  public int _count;

  /// <summary>
  /// 当前指针
  /// </summary>
  private int i;

  int ienumerator<int>.current
  {
   [debuggerhidden]
   get
   {
    return _current;
   }
  }

  object ienumerator.current
  {
   [debuggerhidden]
   get
   {
    return _current;
   }
  }

  [debuggerhidden]
  public getrandomnumbersclass(int state)
  {
   this._state = state;
   _initialthreadid = environment.currentmanagedthreadid;
  }

  [debuggerhidden]
  void idisposable.dispose()
  {
  }

  private bool movenext()
  {
   switch (_state)
   {
    default:
     return false;
    case 0:
     _state = -1;
     i = 0;
     break;
    case 1:
     _state = -1;
     i++;
     break;
   }
   if (i < count)
   {
    _current = r.next(10);
    _state = 1;
    return true;
   }
   return false;
  }

  bool ienumerator.movenext()
  {
   //ilspy generated this explicit interface implementation from .override directive in movenext
   return this.movenext();
  }

  [debuggerhidden]
  void ienumerator.reset()
  {
   throw new notsupportedexception();
  }

  [debuggerhidden]
  public ienumerator<int> getenumerator()
  {
   getrandomnumbersclass _getrandom;
   if (_state == -2 && _initialthreadid == environment.currentmanagedthreadid)
   {
    _state = 0;
    _getrandom = this;
   }
   else
   {
    _getrandom = new getrandomnumbersclass(0);
   }
   _getrandom.count = _count;
   return _getrandom;
  }

  [debuggerhidden]
  ienumerator ienumerable.getenumerator()
  {
   return getenumerator();
  }


  [iteratorstatemachine(typeof(getrandomnumbersclass))]
  private static ienumerable<int> getlist(int count)
  {
   getrandomnumbersclass getrandomnumbersclass = new getrandomnumbersclass(-2);
   getrandomnumbersclass._count = count;
   return getrandomnumbersclass;
  }
  private static void main(string[] args)
  {
   ienumerator<int> enumerator = getlist(5).getenumerator();
   try
   {
    foreach (int item in getlist(5))
     console.writeline(item);
    //while (enumerator.movenext())
    //{
    // int current = enumerator.current;
    // console.writeline(current);
    //}
   }
   finally
   {
    if (enumerator != null)
    {
     enumerator.dispose();
    }
   }
   console.readkey();
  }
 }

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。