欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

C# 中yield关键字解析

程序员文章站 2023-10-30 23:29:28
前言 前段时间了解到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;
        }


    }

C# 中yield关键字解析

通过代码的运行结果,我们可以看到这里返回的结果 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;
            }
        } 
    }

C# 中yield关键字解析

我们看这个运行结果,这里yield return 和comment return 的输出完全交替了。这里说明是一次调用就返回了一个元素。

通过上面的案例我们可以发现,yield return 并不是等所有执行完了才一次性返回的。而是调用一次就返回一次结果的元素。这也就是按需供给。

解析定义类

我们已经大致了解了yield 的用法和它与平常的返回的区别。我们可以继续查看其运行原理。我们首先看这么一个案例(在0-10中随机返回五个数字):

我们通过sharplab反编译其代码,我们进行查看发现yield具体详细实现:

C# 中yield关键字解析 C# 中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#基础知识详解系列

   欢迎大家扫描下方二维码,和我一起学习更多的知识