yield return

最新推荐文章于 2024-08-14 21:15:00 发布
最新推荐文章于 2024-08-14 21:15:00 发布
阅读量3k 收藏
点赞数
文章标签： class iterator string tree list null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jasonvip_c/article/details/5831748
版权

yield return语句返回集合的一个元素，并移动到下一个元素上。yield break可停止迭代。包含yield语句的方法或属性也称为迭代块。迭代块必须声明为返回IEnumerator或IEnumerable接口。这个块可以包含多个yield return语句或yield break语句，但不能包含return语句。

下面是事例

view plaincopy to clipboardprint?
using System;  
using System.Collections.Generic;  
using System.Text;  
using System.Collections.Specialized;  
using System.Collections;  
using System.Diagnostics;  
namespace ConsoleTest  
{  
    public class ConsoleTest  
    {  
        public static void Main(string[] args)  
        {  
            // Test 1.   
            // yield break.  
            // yield return. 
            
           #region Test 1  
            ListClass list = new ListClass();  
            foreach (string i in list)  
            {  
                Console.Write(i);  
            } 
           #endregion  
 
            // Test 2 yield Iterator. 
           #region Test 2  
            Node<string>[] nodes = new Node<string>[8];  
            nodes[0] = new Node<string>("A");  
            nodes[1] = new Node<string>("B");  
            nodes[2] = new Node<string>("C");  
            nodes[3] = new Node<string>("D");  
            nodes[4] = new Node<string>("E");  
            nodes[5] = new Node<string>("F");  
            nodes[6] = new Node<string>("G");  
            nodes[7] = new Node<string>("H");  
            nodes[0].LeftNode = nodes[1];  
            nodes[0].RightNode = nodes[2];  
            nodes[1].RightNode = nodes[3];  
            nodes[2].LeftNode = nodes[4];  
            nodes[2].RightNode = nodes[5];  
            nodes[3].LeftNode = nodes[6];  
            nodes[3].RightNode = nodes[7];  
            BinaryTree<string> tree = new BinaryTree<string>(nodes[0]);  
            BinaryTreeScanInOrder<string> inOrder = new BinaryTreeScanInOrder<string>(tree);  
            foreach (string item in inOrder.InOrder)  
            {  
                Console.WriteLine(item);  
            }  
            Console.ReadLine(); 
           #endregion  
        }  
    } 
    #region For Test 1  
    public class ListClass : IEnumerable  
    {  
        public IEnumerator GetEnumerator()  
        {  
            yield return "With an iterator, ";  
            yield return "more than one ";  
            yield break;  
            yield return "value can be returned";  
            yield return ".";  
        }  
    } 
    #endregion 
    #region For Test 2  
    public class Node<T>  
    {  
        public Node<T> LeftNode;  
        public Node<T> RightNode;  
        public T Item;  
        public Node(T item)  
        {  
            this.Item = item;  
        }  
    }  
    public class BinaryTree<T>  
    {  
        public Node<T> Root;  
        public BinaryTree(Node<T> root)  
        {  
            this.Root = root;  
        }  
    }  
    public class BinaryTreeScanInOrder<T>  
    {  
        private BinaryTree<T> _binaryTree;  
        public BinaryTreeScanInOrder(BinaryTree<T> binaryTree)  
        {  
            this._binaryTree = binaryTree;  
        }  
        public IEnumerable<T> InOrder  
        {  
            get 
            {  
                return ScanInOrder(_binaryTree.Root);  
            }  
        }  
        public IEnumerable<T> ScanInOrder(Node<T> root)  
        {  
            if (root.LeftNode != null)  
            {  
                foreach (T item in ScanInOrder(root.LeftNode))  
                {  
                    yield return item;  
                }  
            }  
            yield return root.Item;  
            if (root.RightNode != null)  
            {  
                foreach (T item in ScanInOrder(root.RightNode))  
                {  
                    yield return item;  
                }  
            }  
        }  
    } 
    #endregion  
} 
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections.Specialized;
using System.Collections;
using System.Diagnostics;
namespace ConsoleTest
{
    public class ConsoleTest
    {
        public static void Main(string[] args)
        {
            // Test 1.
            // yield break.
            // yield return.
          
           #region Test 1
            ListClass list = new ListClass();
            foreach (string i in list)
            {
                Console.Write(i);
            }
           #endregion

            // Test 2 yield Iterator.
           #region Test 2
            Node<string>[] nodes = new Node<string>[8];
            nodes[0] = new Node<string>("A");
            nodes[1] = new Node<string>("B");
            nodes[2] = new Node<string>("C");
            nodes[3] = new Node<string>("D");
            nodes[4] = new Node<string>("E");
            nodes[5] = new Node<string>("F");
            nodes[6] = new Node<string>("G");
            nodes[7] = new Node<string>("H");
            nodes[0].LeftNode = nodes[1];
            nodes[0].RightNode = nodes[2];
            nodes[1].RightNode = nodes[3];
            nodes[2].LeftNode = nodes[4];
            nodes[2].RightNode = nodes[5];
            nodes[3].LeftNode = nodes[6];
            nodes[3].RightNode = nodes[7];
            BinaryTree<string> tree = new BinaryTree<string>(nodes[0]);
            BinaryTreeScanInOrder<string> inOrder = new BinaryTreeScanInOrder<string>(tree);
            foreach (string item in inOrder.InOrder)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();
           #endregion
        }
    }
    #region For Test 1
    public class ListClass : IEnumerable
    {
        public IEnumerator GetEnumerator()
        {
            yield return "With an iterator, ";
            yield return "more than one ";
            yield break;
            yield return "value can be returned";
            yield return ".";
        }
    }
    #endregion
    #region For Test 2
    public class Node<T>
    {
        public Node<T> LeftNode;
        public Node<T> RightNode;
        public T Item;
        public Node(T item)
        {
            this.Item = item;
        }
    }
    public class BinaryTree<T>
    {
        public Node<T> Root;
        public BinaryTree(Node<T> root)
        {
            this.Root = root;
        }
    }
    public class BinaryTreeScanInOrder<T>
    {
        private BinaryTree<T> _binaryTree;
        public BinaryTreeScanInOrder(BinaryTree<T> binaryTree)
        {
            this._binaryTree = binaryTree;
        }
        public IEnumerable<T> InOrder
        {
            get
            {
                return ScanInOrder(_binaryTree.Root);
            }
        }
        public IEnumerable<T> ScanInOrder(Node<T> root)
        {
            if (root.LeftNode != null)
            {
                foreach (T item in ScanInOrder(root.LeftNode))
                {
                    yield return item;
                }
            }
            yield return root.Item;
            if (root.RightNode != null)
            {
                foreach (T item in ScanInOrder(root.RightNode))
                {
                    yield return item;
                }
            }
        }
    }
    #endregion
}

一个迭代器块（iterator block）是一个能够产生有序的值序列的块。迭代器块和普通语句块的区别就是其中出现的一个或多个yield语句。

yield return语句产生迭代的下一个值。
yield break语句表示迭代完成。
只要相应的函数成员的返回值类型是一个枚举器接口（见下）或是一个可枚举接口（见下），一个迭代器块就可以用作方法体、运算符体或访问器体。

迭代器块并不是C#语法中的独立元素。它们受多种因素的制约，并且对函数成员声明的语义有很大影响，但在语法上它们只是块（block）。

当一个函数成员用一个迭代器块来实现时，如果函数成员的形式参数列表指定了ref或out参数，则会引起编译错误。

如果在迭代器块中出现了return语句，则会因此编译错误（但yield return语句是允许的）。

如果迭代器块包含不安全上下文，则会引起编译错误。一个迭代器块必须定义在一个安全的上下文中，即使它的声明嵌套在一个不安全上下文中。

 枚举器接口
枚举器（enumerator）接口包括非泛型接口System.Collections.IEnumerator和泛型接口System.Collections.Generic.IEnumerator<T>的所有实例化。在这一章中，这些接口将分别称作IEnumerator和IEnumerator<T>。

 可枚举接口
可枚举（enumerable）接口包括非泛型接口System.Collections.IEnumerable和泛型接口System.Collections.Generic.IEnumerable<T>。在这一章中，这些接口分别称作IEnumerable和IEnumerable<T>。

生成类型

一个迭代器块能够产生一个有序的值序列，其中所有的制具有相同的类型。这个类型称为迭代器块的生成类型（yield type）。

jasonvip_c
关注
Unity协程（一）：彻底了解yield return null 和 yield return new WaitForSeconds
fdyshlk的博客
05-23 5万+
unity的协程毫无疑问是个非常棒的设计，但是也存在着一些坑和一些误区。
C# yield return 的作用简单说明
ManGo丨XYZ
03-27 529
好久没写C# 今天心血来潮突然看了下C#的代码 看到了一个yield 想知道这个是什么用途的情况下才有了这篇文章 百度了一下这个东西出来代码都是写了一堆的东西，看着太累人了去官网看了下大致知道这个是什么用的了 下面就非常简单的说下作用直接给代码加备注 using System; using System.Threading.Tasks; namespace ConsoleApp1 { class Program { static void Main(string..
C#中yield return用法分析
09-04
主要介绍了C#中yield return用法,对比使用yield return与不使用yield return的流程,更直观的分析了yield return的用法,需要的朋友可以参考下
迭代器（yield return ）
weixin_34242819的博客
06-03 94
yield return语句返回集合的一个元素，并移动到下一个元素上。yield break可停止迭代。包含yield语句的方法或属性也称为迭代块。迭代块必须声明为返回IEnumerator或IEnumerable接口。这个块可以包含多个yield return语句或yield break语句，但不能包含return语句。 下面是事例 代码view plaincopy to clipboard...
深入理解C#中的yield关键字：提升迭代性能与效率
最新发布
拥有必珍惜
08-14 1286
在C#中，yield 关键字是特别用于迭代器块和方法中的，它允许你逐个返回序列中的元素，而不是一次性返回整个集合。使用 yield 可以显著提高处理大数据集或进行复杂迭代时的性能和内存效率，因为它允许按需生成和返回数据，而不是预先生成整个数据集。含有 yield return 语句的方法必须返回 IEnumerable、IEnumerable、IEnumerator 或 IEnumerator。
[C#基础知识系列]专题十二:迭代器
weixin_34319374的博客
12-02 142
 引言:  　　在C# 1.0中我们经常使用foreach来遍历一个集合中的元素,然而一个类型要能够使用foreach关键字来对其进行遍历必须实现IEnumerable或IEnumerable&lt;T&gt;接口,(之所以来必须要实现IEnumerable这个接口,是因为foreach是迭代语句,要使用foreach必须要有一个迭代器才行的，然而IEnumerable接口中就有IEnumera...
Yield Return
qq_34702563的博客
01-24 395
摘自：彻底搞懂C#之Yield Return语法的作用和好处 我们假如有1000000个数据，我们需要得到里面的耦合，当我们通过这个方法得到一个耦合会立马显示在控制台上。而不是等很久也就把全部偶数都查找到存入集合当中，然后在一一遍历输出。 这个好处是很大的。比如我们用户可能就看数据开始肯定不是全部值需要部分就可以，看完这些在看后面的，这样数据会让觉得显示没有延迟。 ...
c# yield return用法
习惯冬天的静谧
03-27 2470
yield return null; // 下一帧再执行后续代码 yield return 0; //下一帧再执行后续代码 yield return 6;//(任意数字) 下一帧再执行后续代码 yield break; //直接结束该协程的后续操作 yield return asyncOperation;//等异步操作结束后再执行后续代码 yield return StartCoroution(...
yield return
白羊兽瞳
12-15 347
1.协程的作用总结起来就是一句话：控制代码在特定的时机执行。      2.请你牢记：协程不是线程，也不是异步执行的。协程和 MonoBehaviour 的 Update函数一样也是在MainThread中执行的。使用协程你不用考虑同步和锁的问题。          3.协程是一个分部执行，遇到条件（yield return 语句）会挂起，直到条件满足才会被唤醒继续执行后面的代码
yield return 的使用方法
weixin_34245082的博客
12-24 230
以下代码，返回List，list内容为大于60的项 public Form1() { 　　InitializeComponent(); } private void Form1_Load(object sender, EventArgs e) { 　　IEnumerable<i...
yield和 return
qq_33726988的博客
08-01 753
return可以往法外传递一个值  从之后return之后的代码不再执行 yield 也可以往方法里面传递一个值 但是传递之后继续执行后面的代码 通过yield传递的值的方法是一个可以迭代的对象 return def test1(name): print('return方法') return name print('return方法结束') name = test...
yield 和 return
咖乐部
02-23 295
作用类似于return，只不过yield返回的是一个迭代器（generator），可以配合特殊的方法：next（）、send（）函数使用。 1.调用：含有yield特殊字的函数，被调用之后返回的是一个迭代器 def foo(): i = 1 print("starting...") while True: yield i+1 i+=1 print(i) g = foo() print(g) 》》》 <generator
yield和return
zfx1997的博客
03-07 284
return： import time def sayHi2(**kargs): for i in range(10): time.sleep(1) return 'loop', i result = sayHi2(name='Alex', age=29, phone=1355434) print result print result print r...
python中yield和return究竟有什么区别，怎么用？
weixin_30352645的博客
04-05 168
yield yield是用于生成器。什么是生成器，你可以通俗的认为，在一个函数中，使用了yield来代替return的位置的函数，就是生成器。它不同于函数的使用方法是：函数使用return来进行返回值，每调用一次，返回一个新加工好的数据返回给你；yield不同，它会在调用生成器的时候，把数据生成object，然后当你需要用的时候，要用next()方法来取，同时不可逆。你可以通俗的叫它"轮转容器"，...
//yield return用于无缝实现迭代模式。
weixin_34050005的博客
06-27 203
代码 publicclassYieldReturn{//yieldreturn用于无缝实现迭代模式。string[]strArr;publicYieldReturn(paramsstring[]arr){strArr=newstring[arr.Length];...
Yield Return的使用
木小星的博客
10-16 1009
  1.如果只是等待下一帧执行，用yield return null即可,在这之前update执行了两次。调用顺序在Update后，LateUpdate前。   2.如果有截屏需要，用WaitForEndOfFrame。具体参考官方例子。否则直接用Texture2D.ReadPixel抓取屏幕信息则会报错。   3.此外，用WaitForEndOfFrame还可以让代码在LateUpdate的时序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值