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();
        }
    }

 

　

---

 

　用爱生活，你会使本身幸福！用爱工做，你会使不少人幸福！ 

   C#基础知识详解系列

   欢迎你们扫描下方二维码，和我一块儿学习更多的知识😊