从yield关键字看IEnumerable和Collection的区别

C#的yield关键字由来以久,如果我没有记错的话,应该是在C# 2.0中被引入的。相信大家此关键字的用法已经了然于胸,很多人也了解yield背后的“延迟赋值”机制。但是即使你知道这个机制,你也很容易在不经意间掉入它制造的陷阱。

目录 一、一个很简单的例子 二、简单谈谈“延迟赋值” 三、从反射的代码帮助我们更加直接的了解yield导致的延迟赋值 四、如果需要“立即赋值”怎么办? 后记

一、一个很简单的例子

下面是一个很简单的例子:Vector为自定义表示二维向量的类型,Program的静态方法GetVetors方法获取以类型为IEnumerable<Vector> 表示的Vector列表,而方法通过yield关键字返回三个Vectior对象。在Main方法中,将GetVetors方法的返回值赋值给一个变量,然后对每一个Vector对象的X和Y进行重新赋值,最后将每一个Vector的信息输出来。从最后的输出我们不难看出,我们对Vector的重新赋值无效,最终的每一个Vector元素依旧“保持”着初始值。

class Program
{
    static void Main(string[] args)
    {
        IEnumerable<Vector> vectors = GetVectors();
        foreach (var vector in vectors)
        {
            vector.X = 4;
            vector.Y = 4;
        }

        foreach (var vector in vectors)
        {
            Console.WriteLine(vector);
        }            
    }

    static IEnumerable<Vector> GetVectors()
    {
        yield return new Vector(1, 1);
        yield return new Vector(2, 3);
        yield return new Vector(3, 3);
    }
}
public class Vector
{
    public double X { get; set; }
    public double Y { get; set; }
    public Vector(double x, double y)
    {
        this.X = x;
        this.Y = y;
    }

    public override string ToString()
    {
        return string.Format("X = {0}, Y = {1}", this.X, this.Y);
    }
}
输出结果:
   1: X = 1, Y = 1
   2: X = 2, Y = 3
   3: X = 3, Y = 3

二、简单谈谈“延迟赋值”

对于上面的现象,很多人一眼就可以看出这是由于yield背后的“延迟赋值”机制导致,但是不可否认我们会不经意间犯这种错误。为了让大家对这个问题有稍微深刻的认识,我们还是简单来谈谈“延迟赋值”。延迟赋值(Delay|Lazy Evaluation)又被称为延迟计算。为了避免不必要的计算导致的性能损失,和LINQ查询一样,yield关键字并不会导致后值语句的立即执行,而是转换成一个“表达式”。只有等到需要的那一刻(进行迭代)的时候,表达式被才被执行。

针对上面这个例子,我们对其进行简单的修改来验证“延迟赋值”的存在。我我们只需要在Vector的构造函数中添加一行语句:Console.WriteLine("Vector object is instantiated.");。从运行后的结过我们可以看出,Vector对象被创建了6次,来自于两次迭代。一次是对Vector元素的重新赋值,另一次源自对Vector元素的输出。由于两次迭代造作的并不是同一批对象,才会导致X和Y属性依然“保持”着原始的值。

   1: public class Vector
   2: {
   3:     //.....
   4:     public Vector(double x, double y)
   5:     {
   6:         Console.WriteLine("Vector object is instantiated.");
   7:         this.X = x;
   8:         this.Y = y;
   9:     }
  10: }

输出结果:

1: Vector object is instantiated.

2: Vector object is instantiated.

3: Vector object is instantiated.

4: Vector object is instantiated.

5: X = 1, Y = 1

6: Vector object is instantiated.

7: X = 2, Y = 3

8: Vector object is instantiated.

9: X = 3, Y = 3

三、从反射的代码帮助我们更加直接的了解yield导致的延迟赋值

通过Reflector对编译后的代码进行发射,可以为我们更加“赤裸”地揭示yield导致的延迟赋值,下面的代码片断是对Program类型的“本质”反映。

   1: internal class Program
   2: {
   3:     private static IEnumerable<Vector> GetVectors()
   4:     {
   5:         return new <GetVectors>d__0(-2);
   6:     }
   7:  
   8:     private static void Main(string[] args)
   9:     {
  10:         IEnumerable<Vector> vectors = GetVectors();
  11:         foreach (Vector vector in vectors)
  12:         {
  13:             vector.X = 4.0;
  14:             vector.Y = 4.0;
  15:         }
  16:         foreach (Vector vector in vectors)
  17:         {
  18:             Console.WriteLine(vector);
  19:         }
  20:     }    
  21: }
  22:  
  23:  

从上面的代码我们可以看到,通过yield关键字实现的GetVectors方法最终返回值是一个<GetVectors>d__0 类型的对象,该对象定义如下:

   1: [CompilerGenerated]
   2: private sealed class <GetVectors>d__0 : IEnumerable<Vector>, IEnumerable, IEnumerator<Vector>, IEnumerator, IDisposable
   3: {
   4:     private int <>1__state;
   5:     private Vector <>2__current;
   6:     private int <>l__initialThreadId;
   7:  
   8:     [DebuggerHidden]
   9:     public <GetVectors>d__0(int <>1__state);
  10:     private bool MoveNext();
  11:     [DebuggerHidden]
  12:     IEnumerator<Vector> IEnumerable<Vector>.GetEnumerator();
  13:     [DebuggerHidden]
  14:     IEnumerator IEnumerable.GetEnumerator();
  15:     [DebuggerHidden]
  16:     void IEnumerator.Reset();
  17:     void IDisposable.Dispose();
  18:  
  19:     Vector IEnumerator<Vector>.Current { [DebuggerHidden] get; }
  20:     object IEnumerator.Current { [DebuggerHidden] get; }
  21: }

这是一个实现了众多接口的类型,实现的接口包括:IEnumerable<Vector>, IEnumerable, IEnumerator<Vector>, IEnumerator, IDisposable。<GetVectors>d__0 类大部分成员都没有复杂的逻辑,唯一值得一提的就是MoveNext方法。从中我们清楚地但到,对Vector对象的创建发生在每一个迭代中。

   1: private bool MoveNext()
   2: {
   3:     switch (this.<>1__state)
   4:     {
   5:         case 0:
   6:             this.<>1__state = -1;
   7:             this.<>2__current = new Vector(1.0, 1.0);
   8:             this.<>1__state = 1;
   9:             return true;
  10:  
  11:         case 1:
  12:             this.<>1__state = -1;
  13:             this.<>2__current = new Vector(2.0, 3.0);
  14:             this.<>1__state = 2;
  15:             return true;
  16:  
  17:         case 2:
  18:             this.<>1__state = -1;
  19:             this.<>2__current = new Vector(3.0, 3.0);
  20:             this.<>1__state = 3;
  21:             return true;
  22:  
  23:         case 3:
  24:             this.<>1__state = -1;
  25:             break;
  26:     }
  27:     return false;
  28: }
  29:  

四、如果需要“立即赋值”怎么办?

有时候我们不需要“延迟赋值”,而需要“立即赋值”,因为调用着需要维护它们的状态,那该怎么办呢?有人说,不用yield不久得到吗?但是有的情况下,我们需要调用别人提供的API来获取IEnumerable<T>对象,我们不清楚对方有没有使用yield关键字。在这种情况我个人常用的做法就是调用ToArray或者ToList将其转换成T[]或者List<T>,进而进行强制赋值。由于它们也实现了接口IEnumerable<T>,所以不会存在什么问题。同样是对于我们的例子,我们在对GetVectors方法的返回值进行变量赋值的时候的调用ToArray或者ToList方法,我们就能对元素进行有效赋值。

   1: class Program
   2: {
   3:     //......
   4:     static void Main(string[] args)
   5:     {
   6:         IEnumerable<Vector> vectors = GetVectors().ToList();
   7:         foreach (var vector in vectors)
   8:         {
   9:             vector.X = 4;
  10:             vector.Y = 4;
  11:         }
  12:  
  13:         foreach (var vector in vectors)
  14:         {
  15:             Console.WriteLine(vector);
  16:         }            
  17:     }
  18: }

或者:

   1: class Program
   2: {
   3:     //......
   4:     static void Main(string[] args)
   5:     {
   6:         IEnumerable<Vector> vectors = GetVectors().ToArray();
   7:         foreach (var vector in vectors)
   8:         {
   9:             vector.X = 4;
  10:             vector.Y = 4;
  11:         }
  12:  
  13:         foreach (var vector in vectors)
  14:         {
  15:             Console.WriteLine(vector);
  16:         }            
  17:     }
  18: }

输出结果:

1: X = 4, Y = 4

2: X = 4, Y = 4

3: X = 4, Y = 4

后记

其实本篇文章的意图并不在于yield这个关键字如何如何,因为不止是yield,我们一般的LINQ查询也会导致这个问题,而是借此说明IEnumerable对象和Array、List这样的集合类型的区别。IEnumerable这个接口和集合没有本质的联系,只是提供“枚举”的功能。甚至说,我们应该将IEnumerable对象当成“只读”的,如果我们需要“可写”的功能,你应该使用数组或者集合类型。至于本文提到的“延迟赋值”或者“延迟计算”,如果就“枚举”功能而言,也不是很准确,因为“枚举”不承诺“赋值”。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏hbbliyong

看到他我一下子就悟了-- 泛型(1)

1.泛型概念:       本质上,术语”泛型”指的是”参数化类型(parameterized types)”.参数化类型非常重要,因为它们可以在创建类.结构....

2865
来自专栏大内老A

深入理解C# 3.x的新特性(2):Extension Method[下篇]

四、Extension Method的本质 通过上面一节的介绍,我们知道了在C#中如何去定义一个Extension Method:它是定义在一个Static c...

2079
来自专栏GreenLeaves

C# 委托的一些使用上的小技巧

1、委托是一种数据类型,我们可以在任何定义类的地方定义委托,在任何声明类的地方声明委托 2、初始化委托有两种方式,代码如下: (1)、像类一样初始化委托 pub...

2076
来自专栏风口上的猪的文章

.NET面试题系列[9] - IEnumerable

IEnumerable及IEnumerable的泛型版本IEnumerable<T>是一个接口,它只含有一个方法GetEnumerator。Enumerable...

1242
来自专栏机器学习入门

POJ 刷题系列:2739. Sum of Consecutive Prime Numbers

POJ 刷题系列:2739. Sum of Consecutive Prime Numbers 传送门:POJ 2739. Sum of Consecutive...

2127
来自专栏Kiba518

C#语法——泛型的多种应用

泛型是.NET Framework 2.0 版类库就已经提供的语法,主要用于提高代码的可重用性、类型安全性和效率。

943
来自专栏GreenLeaves

C# 通过IEnumberable接口和IEnumerator接口实现自定义集合类型foreach功能

1、IEnumerator和IEnumerable的作用 其实IEnumerator和IEnumerable的作用很简单,就是让除数组和集合之外的类型也能支持f...

20610
来自专栏一枝花算不算浪漫

[读书笔记]C#学习笔记五: C#3.0自动属性,匿名属性及扩展方法

35510
来自专栏技术博客

C#基础知识系列一(goto、i++、三元运算符、ref和out、String和string、重载运算符)

  这两天在网上看到的总结很多,尤其是博客园中的,很多很多,也给了我很多的启发,当然自己也总结过,而且有很多人也给与我一些意见和看法。不管怎样,自己还是先把所谓...

1262
来自专栏IT进修之路

原 分分钟看懂java用引用传递与值传递在

1915

扫码关注云+社区

领取腾讯云代金券