C# 基础小知识之yield 关键字

对于yield关键字我们首先看一下msdn的解释：

如果你在语句中使用 yield 关键字，则意味着它在其中出现的方法、运算符或 get 访问器是迭代器。 通过使用 yield 定义迭代器，可在实现自定义集合类型的 IEnumerable 和 IEnumerator 模式时无需其他显式类（保留枚举状态的类，有关示例，请参阅 IEnumerator<T>）。

yield是一个语法糖

看msdn 的解释总是让人感觉生硬难懂。其实yield关键字很好理解。首先我们对于性质有个了解。yield是一个语法糖。既然yield是在C#中的一个语法糖，那么就说明yield是对一种复杂行为的简化，就是将一段代码简化为一种简单的形式，方便我们程序员使用。

那么yield到底是对什么行为的简化。我们首先来看一下yield的使用场景。

还是来看msdn上的例子。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {

            foreach (int i in Power(2, 8, ""))
            {
                Console.Write("{0} ", i);
            }
            Console.ReadKey();
        }

        public static IEnumerable<int> Power(int number, int exponent, string s)
        {
            int result = 1;

            for (int i = 0; i < exponent; i++)
            {
                result = result * number;
                yield return result;
            }
            yield return 3;
            yield return 4;
            yield return 5;
        }

    }
}

这是msdn上yield的一种使用场景。

我们首先看一下下面的Power方法。该静态方法返回一个IEnumerablel<int>类型的参数。按照我们平常的做法。应该对数据执行一定操作，然后return一个IEnumerablel<int>类型的参数。我们把Power方法改造如下：

 public static IEnumerable<int> Power(int number, int exponent, string s)
        {
            int result = 1;
            //接口不能实例化，我们这儿new一个实现了IEnumerable接口的List
            IEnumerable<int> example = new List<int>();
            for (int i = 0; i < exponent; i++)
            {
                result = result * number;
                (example as List<int>).Add(result);
            }
            return example;
        }

语法糖的实现（实现IEnumerable<T>接口的类）

这是我们平常的思路。但是这样做就有个问题。这儿要new一个List,或者任何实现了IEnumerable接口的类型。这样也太麻烦了吧。要知道IEnumerable是一个常用的返回类型。每次使用都要new一个LIst,或者其他实现了该接口的类型。与其使用其他类型，不如我们自己定制一个实现了IEnumerable接口专门用来返回IEnumerable类型的类型。我们自己定制也很麻烦。所以微软帮我们定制好了。这个类是什么，那就是yield关键字这个语法糖。

我们来看一下yield的反编译代码。

namespace ConsoleApplication2
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Runtime.CompilerServices;

    internal class Program
    {
        private static void Main(string[] args)
        {
            IEnumerable<int> enumerable = Power(2, 8);
            Console.WriteLine("Begin to iterate the collection.");
            foreach (int num in Power(2, 8))
            {
                Console.Write("{0} ", num);
            }
            Console.ReadKey();
        }

        public static IEnumerable<int> Power(int number, int exponent)
        {
            <Power>d__0 d__ = new <Power>d__0(-2);
            d__.<>3__number = number;
            d__.<>3__exponent = exponent;
            return d__;
        }

        [CompilerGenerated]
        private sealed class <Power>d__0 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable
        {
            private int <>1__state;
            private int <>2__current;
            public int <>3__exponent;
            public int <>3__number;
            private int <>l__initialThreadId;
            public int <result>5__1;
            public int exponent;
            public int number;

            [DebuggerHidden]
            public <Power>d__0(int <>1__state)
            {
                this.<>1__state = <>1__state;
                this.<>l__initialThreadId = Environment.CurrentManagedThreadId;
            }

            private bool MoveNext()
            {
                switch (this.<>1__state)
                {
                    case 0:
                        this.<>1__state = -1;
                        this.<result>5__1 = 1;
                        Console.WriteLine("Begin to invoke GetItems() method");
                        this.<>2__current = 3;
                        this.<>1__state = 1;
                        return true;

                    case 1:
                        this.<>1__state = -1;
                        this.<>2__current = 4;
                        this.<>1__state = 2;
                        return true;

                    case 2:
                        this.<>1__state = -1;
                        this.<>2__current = 5;
                        this.<>1__state = 3;
                        return true;

                    case 3:
                        this.<>1__state = -1;
                        break;
                }
                return false;
            }

            [DebuggerHidden]
            IEnumerator<int> IEnumerable<int>.GetEnumerator()
            {
                Program.<Power>d__0 d__;
                if ((Environment.CurrentManagedThreadId == this.<>l__initialThreadId) && (this.<>1__state == -2))
                {
                    this.<>1__state = 0;
                    d__ = this;
                }
                else
                {
                    d__ = new Program.<Power>d__0(0);
                }
                d__.number = this.<>3__number;
                d__.exponent = this.<>3__exponent;
                return d__;
            }

            [DebuggerHidden]
            IEnumerator IEnumerable.GetEnumerator()
            {
                return this.System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator();
            }

            [DebuggerHidden]
            void IEnumerator.Reset()
            {
                throw new NotSupportedException();
            }

            void IDisposable.Dispose()
            {
            }

            int IEnumerator<int>.Current
            {
                [DebuggerHidden]
                get
                {
                    return this.<>2__current;
                }
            }

            object IEnumerator.Current
            {
                [DebuggerHidden]
                get
                {
                    return this.<>2__current;
                }
            }
        }
    }
}

反编译代码有三部分，其中程序的入口点   private static void Main(string[] args)    Power方法  public static IEnumerable<int> Power(int number, int exponent) 和我们自己写的代码一样，但是反编译代码中还多了一个密封类

private sealed class <Power>d__0 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable

现在情况已经明了了。yield这个语法糖实现了一个实现 IEnumerable<int>接口的类来返回我们需要到 IEnumerable<int>类型的数据。

我们再看一下反编译后的Power方法

 public static IEnumerable<int> Power(int number, int exponent)
        {
            <Power>d__0 d__ = new <Power>d__0(-2);
            d__.<>3__number = number;
            d__.<>3__exponent = exponent;
            return d__;
        }

此时就确认，的确是使用了实现枚举接口的类来返回我们需要的数据类型。

每次yield return <expression>;就会像该类的实例中添加 一条数据。当yield break;的时候停止添加。

至此yield的用法就很清楚了。当我们需要返回IEnumerable类型的时候，直接yield返回数据就可以了。也不用new一个list,或其他类型。所以yield是一个典型的语法糖。

yield使用中的特殊情况

我们看到编译器将我们yield的数据添加到了一个集合中。Power方法在编译器中实例化了一个实现枚举接口的类型。但是我们在Power方法中写一些方法，编译器会如何处理

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            //这儿调用了方法。
            var test = Power(2, 8, "");
            Console.WriteLine("Begin to iterate the collection.");
            //Display powers of 2 up to the exponent of 8:
            foreach (int i in Power(2, 8, ""))
            {
                Console.Write("{0} ", i);
            }
            Console.ReadKey();
        }
        public static IEnumerable<int> Power(int number, int exponent, string s)
        {
            int result = 1;
            if (string.IsNullOrEmpty(s))
            {
                //throw new Exception("这是一个异常");
                Console.WriteLine("Begin to invoke GetItems() method");
            }

            for (int i = 0; i < exponent; i++)
            {
                result = result * number;
                yield return result;
            }
            yield return 3;
            yield return 4;
            yield return 5;
        }
    }
}

按照我们的理解当我们 var test = Power(2, 8, "");的时候确实调用了Power方法。此时应该程序打印Console.WriteLine("Begin to invoke GetItems() method");然后继续执行 Console.WriteLine("Begin to iterate the collection.");方法。所以打印顺序应该是

Begin to invoke GetItems() method

Begin to iterate the collection.

但是我们运行的时候却发现

打印顺序和我们想象的不同。此时还是去看反编译代码。

namespace ConsoleApplication2
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Runtime.CompilerServices;

    internal class Program
    {
        private static void Main(string[] args)
        {
            IEnumerable<int> enumerable = Power(2, 8, "");
            Console.WriteLine("Begin to iterate the collection.");
            foreach (int num in Power(2, 8, ""))
            {
                Console.Write("{0} ", num);
            }
            Console.ReadKey();
        }

        public static IEnumerable<int> Power(int number, int exponent, string s)
        {
            <Power>d__0 d__ = new <Power>d__0(-2);
            d__.<>3__number = number;
            d__.<>3__exponent = exponent;
            d__.<>3__s = s;
            return d__;
        }

        [CompilerGenerated]
        private sealed class <Power>d__0 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable
        {
            private int <>1__state;
            private int <>2__current;
            public int <>3__exponent;
            public int <>3__number;
            public string <>3__s;
            private int <>l__initialThreadId;
            public int <i>5__2;
            public int <result>5__1;
            public int exponent;
            public int number;
            public string s;

            [DebuggerHidden]
            public <Power>d__0(int <>1__state)
            {
                this.<>1__state = <>1__state;
                this.<>l__initialThreadId = Environment.CurrentManagedThreadId;
            }

            private bool MoveNext()
            {
                switch (this.<>1__state)
                {
                    case 0:
                        this.<>1__state = -1;
                        this.<result>5__1 = 1;
                        if (string.IsNullOrEmpty(this.s))
                        {
                            Console.WriteLine("Begin to invoke GetItems() method");
                        }
                        this.<i>5__2 = 0;
                        while (this.<i>5__2 < this.exponent)
                        {
                            this.<result>5__1 *= this.number;
                            this.<>2__current = this.<result>5__1;
                            this.<>1__state = 1;
                            return true;
                        Label_009D:
                            this.<>1__state = -1;
                            this.<i>5__2++;
                        }
                        this.<>2__current = 3;
                        this.<>1__state = 2;
                        return true;

                    case 1:
                        goto Label_009D;

                    case 2:
                        this.<>1__state = -1;
                        this.<>2__current = 4;
                        this.<>1__state = 3;
                        return true;

                    case 3:
                        this.<>1__state = -1;
                        this.<>2__current = 5;
                        this.<>1__state = 4;
                        return true;

                    case 4:
                        this.<>1__state = -1;
                        break;
                }
                return false;
            }

            [DebuggerHidden]
            IEnumerator<int> IEnumerable<int>.GetEnumerator()
            {
                Program.<Power>d__0 d__;
                if ((Environment.CurrentManagedThreadId == this.<>l__initialThreadId) && (this.<>1__state == -2))
                {
                    this.<>1__state = 0;
                    d__ = this;
                }
                else
                {
                    d__ = new Program.<Power>d__0(0);
                }
                d__.number = this.<>3__number;
                d__.exponent = this.<>3__exponent;
                d__.s = this.<>3__s;
                return d__;
            }

            [DebuggerHidden]
            IEnumerator IEnumerable.GetEnumerator()
            {
                return this.System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator();
            }

            [DebuggerHidden]
            void IEnumerator.Reset()
            {
                throw new NotSupportedException();
            }

            void IDisposable.Dispose()
            {
            }

            int IEnumerator<int>.Current
            {
                [DebuggerHidden]
                get
                {
                    return this.<>2__current;
                }
            }

            object IEnumerator.Current
            {
                [DebuggerHidden]
                get
                {
                    return this.<>2__current;
                }
            }
        }
    }
}

我们看到Power方法

 public static IEnumerable<int> Power(int number, int exponent, string s)
        {
            <Power>d__0 d__ = new <Power>d__0(-2);
            d__.<>3__number = number;
            d__.<>3__exponent = exponent;
            d__.<>3__s = s;
            return d__;
        }

还是还我们没有加打印方法之前一样。我们的打印方法并没有出现在Power方法中，而是被封装进了实现枚举接口的类方法  private bool MoveNext()中。所以方法不会立即被执行，而是在我们使用数据的时候被执行。如果对此机制不了解，就容易出现另外一些意想不到的问题。例如在Power方法中添加一些验证程序，如果不符合条件就抛出一个异常。这样的异常检查不会被执行。只有我们使用数据的时候才会执行。这样就失去了检查数据的意义。

具体的例子可以看Artech博主的文章

另外使用yield还有一些注意事项：

你不能在具有以下特点的方法中包含 yield return 或 yield break 语句：

异常处理

不能将 yield return 语句置于 try-catch 块中。 可将 yield return 语句置于 try-finally 语句的 try 块中。

yield break 语句可以位于 try 块或 catch 块，但不能位于 finally 块。

如果 foreach 主体（在迭代器方法之外）引发异常，则将执行迭代器方法中的 finally 块。

本文地址：http://www.cnblogs.com/santian/p/4389675.html

博客地址：一天两天三天

转载请以超链接形式标明文章原始出处。

时间： 2024-08-28 10:25:00

C# 基础小知识之yield 关键字的相关文章

C# 基础小知识之yield 关键字 语法糖

原文地址:http://www.cnblogs.com/santian/p/4389675.html 对于yield关键字我们首先看一下msdn的解释: 如果你在语句中使用 yield 关键字,则意味着它在其中出现的方法.运算符或 get 访问器是迭代器. 通过使用 yield 定义迭代器,可在实现自定义集合类型的 IEnumerable 和 IEnumerator 模式时无需其他显式类(保留枚举状态的类,有关示例,请参阅 IEnumerator<T>). yield是一个语法糖 看msdn

Java基础小知识（一）

 序言:“不积跬步,无以至千里.不积小流,无以成江海.”每一个庞大的知识架构都是由无数个小知识点慢慢积累起来的,没有量变的积累,就没有质变上的飞跃,成功往往离不开积累. 今天就和大家分享一些我在学习JAVA过程中总结的一些小知识吧! ①JAVA语言规定标识符的命名规则: 标识符应以“字母”.“下划线”.“美元符号$” 开头,不能以“数字”开头: 标识符可以由“字母(A-Z,a-z)”.“下划线”.“美元符号$” 或“数字(0-9)”组成: Java标识符需要注意区分大小写,长度无限制:(类名首字

基础小知识，持续更新中~

一.一些基础小命令 dir = 查看当前目录文件列表 cd .. 返回上一层目录 cd ../.. 返回上上一层目录 二.关于中文编码 #-*- coding:utf-8 -*-print ("中国") 三.设置notepad++ 快捷键 设置--->首选项--->语言---->勾选替换为空格,tab键自动打印4个空格 视图--->显示符号--->显示空格与制表符. 四.注释 # 单行注释'''多行注释'''""" 多行注释

Java 基础小知识 （随学习不断补充）

最近希望巩固一下基础,看了李兴华老师的<Java核心技术精讲>一书,随着学习过程记录整理一下一些零散的小知识点,方便以后记忆. 如有错误和建议,欢迎指出. 1.Java中的关键字 abstract assert boolean break byte case catch char class continue const default do double else extends enum final finally float for goto if implements import i

android&quot;百码&quot;2——基础小知识积累（逐步完善）2015-06-15

自己对java基础知识.语法.基本数据类型等方面都不是很掌握,经常在一些很基础的问题上折腾好一段时间,最近在执行“百码”计划,因此专门写一篇博文用于记录日常编程过程中遇到的一些薄弱知识点,逐个积累起来,填补自己的薄弱环节. 1.Spinner设置默认值 在对spinner设置完数据适配器后,系统默认将数据源的第一个数据作为spinner默认值,很多时候我们需要自定义这个默认值,或者说我们需要通过代码的方式去控制spinner当前值,这时候就需要用到setSelection()函数,使用代码如下:

java基础小知识

1.1常量: 基本数据类型常量 字符常量 整数常量的表现形式:一进制的形式来表示(二进制,八进制,十进制,十六进制) 生活中:十进制(0-9)  ,星期(七进制(0-6)) ,时间(十二进制(0-11),二十四进制(0-23)) 计算机是通过二进制来读取我们生活中的数据. 进制之间的转换: 十进制转为二进制: 将十进制除以2,直到商为0 ,将余数从下上连接起来就是二进制 10---->1010 二进制转十进制:将二进制的每一位乘以2^n ,n从0开始,n每一次加一,在将结果相加. 1001 --

Java的一些基础小知识之JVM与GC (转)

一.JVM是什么 Java虚拟机(英语:Java Virtual Machine,缩写为JVM),又名爪哇虚拟器,一种能够运行Java bytecode的虚拟机,以堆栈结构机器来进行实做.最早由太阳微系统所研发并实现第一个实现版本,是Java平台的一部份,能够运行以Java语言写作的软件程序. Java虚拟机有自己完善的硬体架构,如处理器.堆栈.寄存器等,还具有相应的指令系统.JVM屏蔽了与具体操作系统平台相关的信息,使得Java程序只需生成在Java虚拟机上运行的目标代码(字节码),就可以在多

学习笔记：Java的一些基础小知识之JVM与GC

一.JVM是什么 Java虚拟机(英语:Java Virtual Machine,缩写为JVM),又名爪哇虚拟器,一种能够运行Java bytecode的虚拟机,以堆栈结构机器来进行实做.最早由太阳微系统所研发并实现第一个实现版本,是Java平台的一部份,能够运行以Java语言写作的软件程序. Java虚拟机有自己完善的硬体架构,如处理器.堆栈.寄存器等,还具有相应的指令系统.JVM屏蔽了与具体操作系统平台相关的信息,使得Java程序只需生成在Java虚拟机上运行的目标代码(字节码),就可以在多

前端基础小知识

CSS布局 布局是CSS中一个重要部分,本文总结了CSS布局中的常用技巧,包括常用的水平居中.垂直居中方法,以及单列布局.多列布局的多种实现方式(包括传统的盒模型布局和比较新的flex布局实现),希望能给需要的小伙伴带来一些帮助. 目录 1.常用居中方法:水平居中,垂直居中, 2.单列布局 3.二列&三列布局:float+margin,position+margin,圣杯布局(float+负margin),双飞翼布局(float+负margin),flex布局 如果你想学习交流html5css3