经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » C# » 查看文章
由C# yield return引发的思考
来源:cnblogs  作者:yi念之间  时间:2023/6/2 10:53:23  对本文有异议

前言

    当我们编写 C# 代码时,经常需要处理大量的数据集合。在传统的方式中,我们往往需要先将整个数据集合加载到内存中,然后再进行操作。但是如果数据集合非常大,这种方式就会导致内存占用过高,甚至可能导致程序崩溃。

    C# 中的yield return机制可以帮助我们解决这个问题。通过使用yield return,我们可以将数据集合按需生成,而不是一次性生成整个数据集合。这样可以大大减少内存占用,并且提高程序的性能。

    在本文中,我们将深入讨论 C# 中yield return的机制和用法,帮助您更好地理解这个强大的功能,并在实际开发中灵活使用它。

使用方式

上面我们提到了yield return将数据集合按需生成,而不是一次性生成整个数据集合。接下来通过一个简单的示例,我们看一下它的工作方式是什么样的,以便加深对它的理解

  1. foreach (var num in GetInts())
  2. {
  3. Console.WriteLine("外部遍历了:{0}", num);
  4. }
  5. IEnumerable<int> GetInts()
  6. {
  7. for (int i = 0; i < 5; i++)
  8. {
  9. Console.WriteLine("内部遍历了:{0}", i);
  10. yield return i;
  11. }
  12. }

首先,在GetInts方法中,我们使用yield return关键字来定义一个迭代器。这个迭代器可以按需生成整数序列。在每次循环时,使用yield return返回当前的整数。通过1foreach循环来遍历 GetInts方法返回的整数序列。在迭代时GetInts方法会被执行,但是不会将整个序列加载到内存中。而是在需要时,按需生成序列中的每个元素。在每次迭代时,会输出当前迭代的整数对应的信息。所以输出的结果为

  1. 内部遍历了:0
  2. 外部遍历了:0
  3. 内部遍历了:1
  4. 外部遍历了:1
  5. 内部遍历了:2
  6. 外部遍历了:2
  7. 内部遍历了:3
  8. 外部遍历了:3
  9. 内部遍历了:4
  10. 外部遍历了:4

可以看到,整数序列是按需生成的,并且在每次生成时都会输出相应的信息。这种方式可以大大减少内存占用,并且提高程序的性能。当然从c# 8开始异步迭代的方式同样支持

  1. await foreach (var num in GetIntsAsync())
  2. {
  3. Console.WriteLine("外部遍历了:{0}", num);
  4. }
  5. async IAsyncEnumerable<int> GetIntsAsync()
  6. {
  7. for (int i = 0; i < 5; i++)
  8. {
  9. await Task.Yield();
  10. Console.WriteLine("内部遍历了:{0}", i);
  11. yield return i;
  12. }
  13. }

和上面不同的是,如果需要用异步的方式,我们需要返回IAsyncEnumerable类型,这种方式的执行结果和上面同步的方式执行的结果是一致的,我们就不做展示了。上面我们的示例都是基于循环持续迭代的,其实使用yield return的方式还可以按需的方式去输出,这种方式适合灵活迭代的方式。如下示例所示

  1. foreach (var num in GetInts())
  2. {
  3. Console.WriteLine("外部遍历了:{0}", num);
  4. }
  5. IEnumerable<int> GetInts()
  6. {
  7. Console.WriteLine("内部遍历了:0");
  8. yield return 0;
  9. Console.WriteLine("内部遍历了:1");
  10. yield return 1;
  11. Console.WriteLine("内部遍历了:2");
  12. yield return 2;
  13. }

foreach循环每次会调用GetInts()方法,GetInts()方法的内部便使用yield return关键字返回一个结果。每次遍历都会去执行下一个yield return。所以上面代码输出的结果是

  1. 内部遍历了:0
  2. 外部遍历了:0
  3. 内部遍历了:1
  4. 外部遍历了:1
  5. 内部遍历了:2
  6. 外部遍历了:2

探究本质

上面我们展示了yield return如何使用的示例,它是一种延迟加载的机制,它可以让我们逐个地处理数据,而不是一次性地将所有数据读取到内存中。接下来我们就来探究一下神奇操作的背后到底是如何实现的,方便让大家更清晰的了解迭代体系相关。

foreach本质

首先我们来看一下foreach为什么可以遍历,也就是如果可以被foreach遍历的对象,被遍历的操作需要满足哪些条件,这个时候我们可以反编译工具来看一下编译后的代码是什么样子的,相信大家最熟悉的就是List<T>集合的遍历方式了,那我们就用List<T>的示例来演示一下

  1. List<int> ints = new List<int>();
  2. foreach(int item in ints)
  3. {
  4. Console.WriteLine(item);
  5. }

上面的这段代码很简单,我们也没有给它任何初始化的数据,这样可以排除干扰,让我们能更清晰的看到反编译的结果,排除其他干扰。它反编译后的代码是这样的

  1. List<int> list = new List<int>();
  2. List<int>.Enumerator enumerator = list.GetEnumerator();
  3. try
  4. {
  5. while (enumerator.MoveNext())
  6. {
  7. int current = enumerator.Current;
  8. Console.WriteLine(current);
  9. }
  10. }
  11. finally
  12. {
  13. ((IDisposable)enumerator).Dispose();
  14. }

可以反编译代码的工具有很多,我用的比较多的一般是ILSpydnSpydotPeek和在线c#反编译网站sharplab.io,其中dnSpy还可以调试反编译的代码。

通过上面的反编译之后的代码我们可以看到foreach会被编译成一个固定的结构,也就是我们经常提及的设计模式中的迭代器模式结构

  1. Enumerator enumerator = list.GetEnumerator();
  2. while (enumerator.MoveNext())
  3. {
  4. var current = enumerator.Current;
  5. }

通过这段固定的结构我们总结一下foreach的工作原理

  • 可以被foreach的对象需要要包含GetEnumerator()方法
  • 迭代器对象包含MoveNext()方法和Current属性
  • MoveNext()方法返回bool类型,判断是否可以继续迭代。Current属性返回当前的迭代结果。

我们可以看一下List<T>类可迭代的源码结构是如何实现的

  1. public class List<T> : IList<T>, IList, IReadOnlyList<T>
  2. {
  3. public Enumerator GetEnumerator() => new Enumerator(this);
  4. IEnumerator<T> IEnumerable<T>.GetEnumerator() => Count == 0 ? SZGenericArrayEnumerator<T>.Empty : GetEnumerator();
  5. IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<T>)this).GetEnumerator();
  6. public struct Enumerator : IEnumerator<T>, IEnumerator
  7. {
  8. public T Current => _current!;
  9. public bool MoveNext()
  10. {
  11. }
  12. }
  13. }

这里涉及到了两个核心的接口IEnumerable<IEnumerator,他们两个定义了可以实现迭代的能力抽象,实现方式如下

  1. public interface IEnumerable
  2. {
  3. IEnumerator GetEnumerator();
  4. }
  5. public interface IEnumerator
  6. {
  7. bool MoveNext();
  8. object Current{ get; }
  9. void Reset();
  10. }

如果类实现IEnumerable接口并实现了GetEnumerator()方法便可以被foreach,迭代的对象是IEnumerator类型,包含一个MoveNext()方法和Current属性。上面的接口是原始对象的方式,这种操作都是针对object类型集合对象。我们实际开发过程中大多数都是使用的泛型集合,当然也有对应的实现方式,如下所示

  1. public interface IEnumerable<out T> : IEnumerable
  2. {
  3. new IEnumerator<T> GetEnumerator();
  4. }
  5. public interface IEnumerator<out T> : IDisposable, IEnumerator
  6. {
  7. new T Current{ get; }
  8. }

可以被foreach迭代并不意味着一定要去实现IEnumerable接口,这只是给我们提供了一个可以被迭代的抽象的能力。只要类中包含GetEnumerator()方法并返回一个迭代器,迭代器里包含返回bool类型的MoveNext()方法和获取当前迭代对象的Current属性即可。

yield return本质

上面我们看到了可以被foreach迭代的本质是什么,那么yield return的返回值可以被IEnumerable<T>接收说明其中必有蹊跷,我们反编译一下我们上面的示例看一下反编译之后代码,为了方便大家对比反编译结果,这里我把上面的示例再次粘贴一下

  1. foreach (var num in GetInts())
  2. {
  3. Console.WriteLine("外部遍历了:{0}", num);
  4. }
  5. IEnumerable<int> GetInts()
  6. {
  7. for (int i = 0; i < 5; i++)
  8. {
  9. Console.WriteLine("内部遍历了:{0}", i);
  10. yield return i;
  11. }
  12. }

它的反编译结果,这里咱们就不全部展示了,只展示一下核心的逻辑

  1. //foeach编译后的结果
  2. IEnumerator<int> enumerator = GetInts().GetEnumerator();
  3. try
  4. {
  5. while (enumerator.MoveNext())
  6. {
  7. int current = enumerator.Current;
  8. Console.WriteLine("外部遍历了:{0}", current);
  9. }
  10. }
  11. finally
  12. {
  13. if (enumerator != null)
  14. {
  15. enumerator.Dispose();
  16. }
  17. }
  18. //GetInts方法编译后的结果
  19. private IEnumerable<int> GetInts()
  20. {
  21. <GetInts>d__1 <GetInts>d__ = new <GetInts>d__1(-2);
  22. <GetInts>d__.<>4__this = this;
  23. return <GetInts>d__;
  24. }

这里我们可以看到GetInts()方法里原来的代码不见了,而是多了一个<GetInts>d__1 l类型,也就是说yield return本质是语法糖。我们看一下<GetInts>d__1类的实现

  1. //生成的类即实现了IEnumerable接口也实现了IEnumerator接口
  2. //说明它既包含了GetEnumerator()方法,也包含MoveNext()方法和Current属性
  3. private sealed class <>GetIntsd__1 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable
  4. {
  5. private int <>1__state;
  6. //当前迭代结果
  7. private int <>2__current;
  8. private int <>l__initialThreadId;
  9. public C <>4__this;
  10. private int <i>5__1;
  11. //当前迭代到的结果
  12. int IEnumerator<int>.Current
  13. {
  14. get{ return <>2__current; }
  15. }
  16. //当前迭代到的结果
  17. object IEnumerator.Current
  18. {
  19. get{ return <>2__current; }
  20. }
  21. //构造函数包含状态字段,变向说明靠状态机去实现核心流程流转
  22. public <GetInts>d__1(int <>1__state)
  23. {
  24. this.<>1__state = <>1__state;
  25. <>l__initialThreadId = Environment.CurrentManagedThreadId;
  26. }
  27. //核心方法MoveNext
  28. private bool MoveNext()
  29. {
  30. int num = <>1__state;
  31. if (num != 0)
  32. {
  33. if (num != 1)
  34. {
  35. return false;
  36. }
  37. //控制状态
  38. <>1__state = -1;
  39. //自增 也就是代码里循环的i++
  40. <i>5__1++;
  41. }
  42. else
  43. {
  44. <>1__state = -1;
  45. <i>5__1 = 0;
  46. }
  47. //循环终止条件 上面循环里的i<5
  48. if (<i>5__1 < 5)
  49. {
  50. Console.WriteLine("内部遍历了:{0}", <i>5__1);
  51. //把当前迭代结果赋值给Current属性
  52. <>2__current = <i>5__1;
  53. <>1__state = 1;
  54. //说明可以继续迭代
  55. return true;
  56. }
  57. //迭代结束
  58. return false;
  59. }
  60. //IEnumerator的MoveNext方法
  61. bool IEnumerator.MoveNext()
  62. {
  63. return this.MoveNext();
  64. }
  65. //IEnumerable的IEnumerable方法
  66. IEnumerator<int> IEnumerable<int>.IEnumerable()
  67. {
  68. //实例化<GetInts>d__1实例
  69. <GetInts>d__1 <GetInts>d__;
  70. if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
  71. {
  72. <>1__state = 0;
  73. <GetInts>d__ = this;
  74. }
  75. else
  76. {
  77. //给状态机初始化
  78. <GetInts>d__ = new <GetInts>d__1(0);
  79. <GetInts>d__.<>4__this = <>4__this;
  80. }
  81. //因为<GetInts>d__1实现了IEnumerator接口所以可以直接返回
  82. return <GetInts>d__;
  83. }
  84. IEnumerator IEnumerable.GetEnumerator()
  85. {
  86. //因为<GetInts>d__1实现了IEnumerator接口所以可以直接转换
  87. return ((IEnumerable<int>)this).GetEnumerator();
  88. }
  89. void IEnumerator.Reset()
  90. {
  91. }
  92. void IDisposable.Dispose()
  93. {
  94. }
  95. }

通过它生成的类我们可以看到,该类即实现了IEnumerable接口也实现了IEnumerator接口说明它既包含了GetEnumerator()方法,也包含MoveNext()方法和Current属性。用这一个类就可以满足可被foeach迭代的核心结构。我们手动写的for代码被包含到了MoveNext()方法里,它包含了定义的状态机制代码,并且根据当前的状态机代码将迭代移动到下一个元素。我们大概讲解一下我们的for代码被翻译到MoveNext()方法里的执行流程

  • 首次迭代时<>1__state被初始化成0,代表首个被迭代的元素,这个时候Current初始值为0,循环控制变量<i>5__1初始值也为0。
  • 判断是否满足终止条件,不满足则执行循环里的逻辑。并更改装填机<>1__state为1,代表首次迭代执行完成。
  • 循环控制变量<i>5__1继续自增并更改并更改装填机<>1__state为-1,代表可持续迭代。并循环执行循环体的自定义逻辑。
  • 不满足迭代条件则返回false,也就是代表了MoveNext()以不满足迭代条件while (enumerator.MoveNext())逻辑终止。

上面我们还展示了另一种yield return的方式,就是同一个方法里包含多个yield return的形式

  1. IEnumerable<int> GetInts()
  2. {
  3. Console.WriteLine("内部遍历了:0");
  4. yield return 0;
  5. Console.WriteLine("内部遍历了:1");
  6. yield return 1;
  7. Console.WriteLine("内部遍历了:2");
  8. yield return 2;
  9. }

上面这段代码反编译的结果如下所示,这里咱们只展示核心的方法MoveNext()的实现

  1. private bool MoveNext()
  2. {
  3. switch (<>1__state)
  4. {
  5. default:
  6. return false;
  7. case 0:
  8. <>1__state = -1;
  9. Console.WriteLine("内部遍历了:0");
  10. <>2__current = 0;
  11. <>1__state = 1;
  12. return true;
  13. case 1:
  14. <>1__state = -1;
  15. Console.WriteLine("内部遍历了:1");
  16. <>2__current = 1;
  17. <>1__state = 2;
  18. return true;
  19. case 2:
  20. <>1__state = -1;
  21. Console.WriteLine("内部遍历了:2");
  22. <>2__current = 2;
  23. <>1__state = 3;
  24. return true;
  25. case 3:
  26. <>1__state = -1;
  27. return false;
  28. }
  29. }

通过编译后的代码我们可以看到,多个yield return的形式会被编译成switch...case的形式,有几个yield return则会编译成n+1case,多出来的一个case则代表的MoveNext()终止条件,也就是返回false的条件。其它的case则返回true表示可以继续迭代。

IAsyncEnumerable接口

上面我们展示了同步yield return方式,c# 8开始新增了IAsyncEnumerable<T>接口,用于完成异步迭代,也就是迭代器逻辑里包含异步逻辑的场景。IAsyncEnumerable<T>接口的实现代码如下所示

  1. public interface IAsyncEnumerable<out T>
  2. {
  3. IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default);
  4. }
  5. public interface IAsyncEnumerator<out T> : IAsyncDisposable
  6. {
  7. ValueTask<bool> MoveNextAsync();
  8. T Current { get; }
  9. }

它最大的不同则是同步的IEnumerator包含的是MoveNext()方法返回的是boolIAsyncEnumerator接口包含的是MoveNextAsync()异步方法,返回的是ValueTask<bool>类型。所以上面的示例代码

  1. await foreach (var num in GetIntsAsync())
  2. {
  3. Console.WriteLine("外部遍历了:{0}", num);
  4. }

所以这里的await虽然是加在foreach上面,但是实际作用的则是每一次迭代执行的MoveNextAsync()方法。可以大致理解为下面的工作方式

  1. IAsyncEnumerator<int> enumerator = list.GetAsyncEnumerator();
  2. while (enumerator.MoveNextAsync().GetAwaiter().GetResult())
  3. {
  4. var current = enumerator.Current;
  5. }

当然,实际编译成的代码并不是这个样子的,我们在之前的文章<研究c#异步操作async await状态机的总结>一文中讲解过async await会被编译成IAsyncStateMachine异步状态机,所以IAsyncEnumerator<T>结合yield return的实现比同步的方式更加复杂而且包含更多的代码,不过实现原理可以结合同步的方式类比一下,但是要同时了解异步状态机的实现,这里咱们就不过多展示异步yield return的编译后实现了,有兴趣的同学可以自行了解一下。

foreach增强

c# 9增加了对foreach的增强的功能,即通过扩展方法的形式,对原本具备包含foreach能力的对象增加GetEnumerator()方法,使得普通类在不具备foreach的能力的情况下也可以使用来迭代。它的使用方式如下

  1. Foo foo = new Foo();
  2. foreach (int item in foo)
  3. {
  4. Console.WriteLine(item);
  5. }
  6. public class Foo
  7. {
  8. public List<int> Ints { get; set; } = new List<int>();
  9. }
  10. public static class Bar
  11. {
  12. //给Foo定义扩展方法
  13. public static IEnumerator<int> GetEnumerator(this Foo foo)
  14. {
  15. foreach (int item in foo.Ints)
  16. {
  17. yield return item;
  18. }
  19. }
  20. }

这个功能确实比较强大,满足开放封闭原则,我们可以在不修改原始代码的情况,增强代码的功能,可以说是非常的实用。我们来看一下它的编译后的结果是啥

  1. Foo foo = new Foo();
  2. IEnumerator<int> enumerator = Bar.GetEnumerator(foo);
  3. try
  4. {
  5. while (enumerator.MoveNext())
  6. {
  7. int current = enumerator.Current;
  8. Console.WriteLine(current);
  9. }
  10. }
  11. finally
  12. {
  13. if (enumerator != null)
  14. {
  15. enumerator.Dispose();
  16. }
  17. }

这里我们看到扩展方法GetEnumerator()本质也是语法糖,会把扩展能力编译成扩展类.GetEnumerator(被扩展实例)的方式。也就是我们写代码时候的原始方式,只是编译器帮我们生成了它的调用方式。接下来我们看一下GetEnumerator()扩展方法编译成了什么

  1. public static IEnumerator<int> GetEnumerator(Foo foo)
  2. {
  3. <GetEnumerator>d__0 <GetEnumerator>d__ = new <GetEnumerator>d__0(0);
  4. <GetEnumerator>d__.foo = foo;
  5. return <GetEnumerator>d__;
  6. }

看到这个代码是不是觉得很眼熟了,不错和上面yield return本质这一节里讲到的语法糖生成方式是一样的了,同样的编译时候也是生成了一个对应类,这里的类是<GetEnumerator>d__0,我们看一下该类的结构

  1. private sealed class <GetEnumerator>d__0 : IEnumerator<int>, IEnumerator, IDisposable
  2. {
  3. private int <>1__state;
  4. private int <>2__current;
  5. public Foo foo;
  6. private List<int>.Enumerator <>s__1;
  7. private int <item>5__2;
  8. int IEnumerator<int>.Current
  9. {
  10. get{ return <>2__current; }
  11. }
  12. object IEnumerator.Current
  13. {
  14. get{ return <>2__current; }
  15. }
  16. public <GetEnumerator>d__0(int <>1__state)
  17. {
  18. this.<>1__state = <>1__state;
  19. }
  20. private bool MoveNext()
  21. {
  22. try
  23. {
  24. int num = <>1__state;
  25. if (num != 0)
  26. {
  27. if (num != 1)
  28. {
  29. return false;
  30. }
  31. <>1__state = -3;
  32. }
  33. else
  34. {
  35. <>1__state = -1;
  36. //因为示例中的Ints我们使用的是List<T>
  37. <>s__1 = foo.Ints.GetEnumerator();
  38. <>1__state = -3;
  39. }
  40. //因为上面的扩展方法里使用的是foreach遍历方式
  41. //这里也被编译成了实际生产方式
  42. if (<>s__1.MoveNext())
  43. {
  44. <item>5__2 = <>s__1.Current;
  45. <>2__current = <item>5__2;
  46. <>1__state = 1;
  47. return true;
  48. }
  49. <>m__Finally1();
  50. <>s__1 = default(List<int>.Enumerator);
  51. return false;
  52. }
  53. catch
  54. {
  55. ((IDisposable)this).Dispose();
  56. throw;
  57. }
  58. }
  59. bool IEnumerator.MoveNext()
  60. {
  61. return this.MoveNext();
  62. }
  63. void IDisposable.Dispose()
  64. {
  65. }
  66. void IEnumerator.Reset()
  67. {
  68. }
  69. private void <>m__Finally1()
  70. {
  71. }
  72. }

看到编译器生成的代码,我们可以看到yield return生成的代码结构都是一样的,只是MoveNext()里的逻辑取决于我们写代码时候的具体逻辑,不同的逻辑生成不同的代码。这里咱们就不在讲解它生成的代码了,因为和上面咱们讲解的代码逻辑是差不多的。

总结

    通过本文我们介绍了c#中的yield return语法,并探讨了由它带来的一些思考。我们通过一些简单的例子,展示了yield return的使用方式,知道了迭代器来是如何按需处理大量数据。同时,我们通过分析foreach迭代和yield return语法的本质,讲解了它们的实现原理和底层机制。好在涉及到的知识整体比较简单,仔细阅读相关实现代码的话相信会了解背后的实现原理,这里就不过多赘述了。

    当你遇到挑战和困难时,请不要轻易放弃。无论你面对的是什么,只要你肯努力去尝试,去探索,去追求,你一定能够克服困难,走向成功。记住,成功不是一蹴而就的,它需要我们不断努力和坚持。相信自己,相信自己的能力,相信自己的潜力,你一定能够成为更好的自己。

??欢迎扫码关注我的公众号??

原文链接:https://www.cnblogs.com/wucy/p/17443749.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号