C# 中yield关键字解析
程序员文章站
2022-06-10 19:32:21
前言 前段时间了解到yield关键字，一直觉得还不错。今天给大家分享一下yield关键字的用法。yield return 返回集合不是一次性返回所有集合元素，而是一次调用返回一个元素。具体如何使用yield return 返回集合呢？我们一起往下面看吧。 yield使用介绍 yield return ......
前言
前段时间了解到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();
}
}
用爱生活，你会使自己幸福！用爱工作，你会使很多人幸福！
欢迎大家扫描下方二维码，和我一起学习更多的知识