图解C#高级教程（五）：枚举器和迭代器

于 2024-10-08 21:04:54 发布
阅读量443 收藏 13
点赞数 11
分类专栏： C#编程语言 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/combination1379/article/details/142674424
版权

本章主要介绍 C# 当中枚举器、可枚举类型以及迭代器相关的知识。

文章目录

1. 枚举器和可枚举类型

枚举器为我们提供了一种统一的方式来顺序访问集合中的元素，却不必了解集合内部的具体实现。例如，使用 foreach 语句遍历数组中的元素：

int[] arr = {10, 11, 12, 23};
foreach (int item in arr1)
{
	Console.WriteLine("Item value: {0}", item);
}

可枚举类型允许对象可以被枚举器逐一遍历，也就是说一个类型必须是可枚举的才能使用 foreach 循环进行遍历。

2. IEnumerator 和 IEnumerable 接口

2.1 IEnumerator 接口

一个枚举器必须实现 IEnumerator 接口的 3 个函数成员：

  • Current：返回序列中当前位置的属性。这个属性是只读的，返回的是 object 类型的引用，所以可以返回任何类型。
  • MoveNext 方法把枚举器位置移动到集合中的下一项。返回值为 bool 值，如果新的位置有效，返回 true；否则，返回 fasle。由于枚举器的原始位置在序列中的第一项之前，因此第一次使用 Current 之前必须先调用 MoveNext。
  • Reset 把位置重置为原始状态。

设计的思想就是需要一个标志物（具体可以是引用、指针或者其它方式）能够获得被遍历集合的当前项，能够移动到集合中下一项的方法，以及重置当前位置的方法。

举一个例子，下图的左边是自定义的可枚举类型，右边是枚举器。
在这里插入图片描述

2.2 IEnumerable 接口

可枚举类是指实现了 IEnumerable 接口的类，该接口只有 GetEnumrator 一个成员方法，它返回用于枚举可枚举类型的枚举器对象。

下面是一个结合使用枚举器和自定义可枚举类的例子：

using System;
using System.Collections;

// 自定义整数范围类，实现 IEnumerable 接口
public class IntegerRange : IEnumerable
{
    private int _start;
    private int _end;

    public IntegerRange(int start, int end)
    {
        _start = start;
        _end = end;
    }

    // 实现 IEnumerable 接口的 GetEnumerator 方法
    public IEnumerator GetEnumerator()
    {
        return new IntegerRangeEnumerator(_start, _end);
    }

    // 自定义枚举器类，实现 IEnumerator 接口
    private class IntegerRangeEnumerator : IEnumerator
    {
        private int _start;
        private int _end;
        private int _current;
        private bool _hasStarted;

        public IntegerRangeEnumerator(int start, int end)
        {
            _start = start;
            _end = end;
            _hasStarted = false;
        }

        // 实现 MoveNext()，移动到下一个元素
        public bool MoveNext()
        {
            if (!_hasStarted)
            {
                _current = _start;
                _hasStarted = true;
            }
            else
            {
                _current++;
            }

            return _current <= _end;
        }

        // 实现 Current 属性，返回当前元素
        public object Current
        {
            get
            {
                if (!_hasStarted || _current > _end)
                    throw new InvalidOperationException();
                return _current;
            }
        }

        // 实现 Reset()，重置枚举器状态
        public void Reset()
        {
            _hasStarted = false;
        }
    }
}

class Program
{
    static void Main()
    {
        IntegerRange range = new IntegerRange(1, 5);

        // 使用 foreach 遍历自定义的可枚举类型
        foreach (int number in range)
        {
            Console.WriteLine(number);
        }
    }
}

输出：

1
2
3
4
5

3. 泛型枚举接口

在 C# 中，泛型枚举接口主要包括两个接口：IEnumerable<T> 和 IEnumerator<T>。这两个接口分别用于实现泛型集合的枚举功能，允许集合中的元素在类型安全的情况下被逐个遍历。与非泛型版本相比，泛型接口提供了更好的类型安全性和性能，因为它避免了装箱/拆箱操作以及对 object 的转换。

对于泛型接口形式：

  • IEnumerable<T> 接口的 GetEnumerator 方法返回实现 IEnumerator 枚举器类的实例；
  • 实现 IEnumerator<T> 的类实现了 Current 属性，它返回实际类型的对象，而不是 object 基类的引用。

下面是一个实现 IEnumerable<T> 和 IEnumerator<T> 的简单示例，定义了一个泛型范围类 Range<T>，可以生成从某个起始值到终止值的泛型集合。

using System;
using System.Collections;
using System.Collections.Generic;

// 定义一个泛型范围类，实现 IEnumerable<T>
public class Range<T> : IEnumerable<T> where T : IComparable<T>
{
    private T _start;
    private T _end;
    private Func<T, T> _incrementFunc;

    public Range(T start, T end, Func<T, T> incrementFunc)
    {
        _start = start;
        _end = end;
        _incrementFunc = incrementFunc;
    }

    // 实现 IEnumerable<T> 接口
    public IEnumerator<T> GetEnumerator()
    {
        return new RangeEnumerator(_start, _end, _incrementFunc);
    }

    // 显式实现非泛型的 IEnumerable 接口
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    // 自定义泛型枚举器
    private class RangeEnumerator : IEnumerator<T>
    {
        private T _current;
        private T _start;
        private T _end;
        private Func<T, T> _incrementFunc;
        private bool _hasStarted;

        public RangeEnumerator(T start, T end, Func<T, T> incrementFunc)
        {
            _start = start;
            _end = end;
            _incrementFunc = incrementFunc;
            _hasStarted = false;
        }

        // 实现 IEnumerator<T> 的 Current 属性
        public T Current
        {
            get
            {
                if (!_hasStarted)
                    throw new InvalidOperationException();
                return _current;
            }
        }

        // 实现非泛型的 Current 属性
        object IEnumerator.Current => Current;

        // 实现 MoveNext()，移动到下一个元素
        public bool MoveNext()
        {
            if (!_hasStarted)
            {
                _current = _start;
                _hasStarted = true;
            }
            else
            {
                _current = _incrementFunc(_current);
            }

            return _current.CompareTo(_end) <= 0;
        }

        // 实现 Reset()，重置枚举器
        public void Reset()
        {
            _hasStarted = false;
        }

        // 实现 Dispose() 方法
        public void Dispose() { }
    }
}

class Program
{
    static void Main()
    {
        // 定义一个整数范围的泛型集合
        var range = new Range<int>(1, 5, x => x + 1);

        // 使用 foreach 遍历集合
        foreach (var number in range)
        {
            Console.WriteLine(number);
        }
    }
}

Range<T>代码解释：

  1. Range<T> 是一个泛型类，允许生成从 _start 到 _end 范围的集合。它实现了 IEnumerable<T> 接口，使该集合可以被 foreach 遍历。
  2. incrementFunc 是一个 Func<T, T> 类型的委托，指定如何生成下一个值。这使得 Range<T> 可以用于不同类型的泛型数据。

输出：

1
2
3
4
5

4. 迭代器

C# 从 2.0 版本开始提供了创建枚举器和可枚举类型的简单方式——迭代器。迭代器可为我们自动创建枚举器和可枚举类型。通过迭代器，程序可以按需逐步生成和返回集合中的元素，而无需一次性加载所有元素。

C# 的迭代器是通过使用两个关键字实现的：

  • yield return：用于按需返回集合中的下一个元素。
  • yield break：用于立即终止迭代。

当你实现一个迭代器方法时，C# 编译器会自动生成一个实现 IEnumerable 或 IEnumerable<T> 接口的类，并生成适当的 IEnumerator 或 IEnumerator<T> 枚举器，因此不需要手动编写这些接口的实现代码。迭代器方法可以像常规方法一样被调用，并与 foreach 语句兼容。

4.1 使用迭代器创建枚举器

下面的实例展示了使用迭代器创建枚举器：

class MyClass
{
    public IEnumerator<string> GetEnumerator()
    {
        return BlackAndWhite();     // 返回枚举器
    }

	// 直接产生一个枚举器
    public IEnumerator<string> BlackAndWhite()
    {
        yield return "Black";
        yield return "White";
        yield return "gray";
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass myClass = new MyClass();
            foreach (string color in myClass)
            {
                Console.WriteLine(color);
            }
        }
    }
}

输出如下：

Black
White
gray

编译器自动帮助我们做的工作如下图所示。编译器会为我们添加一个实现一个枚举器必须包含的方法。
在这里插入图片描述

4.2 使用迭代器创建可枚举类

下面的示例展示了使用迭代器创建可枚举类，这里的 BlackAndWhite 方法返回可枚举类型而不是枚举器，因此在 GetEnumrator 方法中需要调用可枚举类型对象的 GetEnumerator 方法来获取枚举器。

class MyClass1
{
    public IEnumerator<string> GetEnumerator()
    {
        IEnumerable<string> myEnum = BlackAndWhite();       // 获取可枚举类型
        return myEnum.GetEnumerator();          // 获取枚举器
    }

    public IEnumerable<string> BlackAndWhite()
    {
        yield return "Black";
        yield return "White";
        yield return "gray";
    }

}

class Program
{
    static void Main(string[] args)
    {
        MyClass1 myClass1 = new MyClass1();

        // 使用类对象
        foreach (string color in myClass1)
        {
            Console.WriteLine(color);
        }

        // 使用类枚举方法
        foreach (string color in myClass1.BlackAndWhite())
        {
            Console.WriteLine(color);
        }
    }
}

在这里插入图片描述

4.3 迭代器作为属性

下面的代码示例主要用来演示两个方面的内容：

  1. 使用迭代器产生具有两个枚举器的类；
  2. 演示迭代器作为属性而不是方法
    这段代码声明了两个属性来定义两个不同的枚举器。GetEnumerator 方法根据 _listFromUVtoIR 布尔变量的值返回两个枚举器中的一个。如果 _listFromUVtoIR 为 true ，则返回 UVtoIR 枚举器；否则，返回 IRtoUV 枚举器。
class Spectrum
{
    bool _listFromUVtoIR;

    string[] colors = { "Red", "Green", "Blue", "Yellow", "Purple", "Orange" };

    public Spectrum(bool isFromUVtoIR)
    {
        _listFromUVtoIR = isFromUVtoIR;
    }

    public IEnumerator<string> GetEnumerator()
    {
        return _listFromUVtoIR? UVtoIR: IRtoUV;
    }

    public IEnumerator<string> UVtoIR
    {
        get
        {
            for (int i = 0; i < colors.Length; i++)
            {
                yield return colors[i];
            }
        }
    }

    public IEnumerator<string> IRtoUV
    {
        get 
        {
            for (nint i = colors.Length - 1; i >= 0; i--)
                yield return colors[i];
        }
    }
}

class Program
{
    static void Main()
    {
        Spectrum startUV = new Spectrum(true);
        Spectrum startIR = new Spectrum(false);

        foreach (string color in startUV)
        {
            Console.Write("{0} ", color);
        }
        Console.WriteLine();
        foreach (string color in startIR)
        {
            Console.Write("{0} ", color);
        }
    }
}

输出：

Red Green Blue Yellow Purple Orange
Orange Purple Yellow Blue Green Red

下面代码的说明。

public IEnumerator<string> IRtoUV
{
    get 
    {
        for (nint i = colors.Length - 1; i >= 0; i--)
            yield return colors[i];
    }
}

IRtoUV 是一个只读属性，它的类型是 IEnumerator<string>。当访问该属性时，get 访问器中的代码会被执行，返回一个 IEnumerator<string> 对象。这个 get 访问器使用了 yield return，因此它定义了一个迭代器，用于逐步返回 colors 数组中的元素，按从后往前的顺序。

4.4 迭代器的使用场景

迭代器的使用场景如下：

  1. 延迟执行
    迭代器提供了按需生成元素的能力，这意味着元素只有在被请求时才会生成。这对于处理大数据集合、流数据或计算开销较大的数据非常有用。举个例子，如果你有一个需要大量计算才能得到的值，使用迭代器可以避免一次性计算所有值，而是每次只计算一个值。
static IEnumerable<int> GenerateLargeNumbers()
{
    for (int i = 0; i < int.MaxValue; i++)
    {
        yield return i;
    }
}
  1. 自定义集合的遍历
    当你创建自定义的数据结构时，可以使用迭代器来定义集合的遍历规则，而不需要手动实现 IEnumerable 和 IEnumerator 接口。例如，使用迭代器遍历二叉树：
using System;
using System.Collections.Generic;

// 定义二叉树节点类
public class TreeNode
{
    public int Value;  // 节点的值
    public TreeNode Left;  // 左子节点
    public TreeNode Right;  // 右子节点

    public TreeNode(int value)
    {
        Value = value;
    }

    // 使用迭代器实现深度优先遍历（前序遍历：根 -> 左 -> 右）
    public IEnumerable<int> PreOrderTraversal()
    {
        // 返回当前节点的值
        yield return Value;

        // 如果左子节点存在，递归遍历左子树
        if (Left != null)
        {
            foreach (var leftValue in Left.DepthFirstTraversal())
            {
                yield return leftValue;
            }
        }

        // 如果右子节点存在，递归遍历右子树
        if (Right != null)
        {
            foreach (var rightValue in Right.DepthFirstTraversal())
            {
                yield return rightValue;
            }
        }
    }
	// 中序遍历:左 -> 根 -> 右）
	public IEnumerable<int> InOrderTraversal()
	{
	    if (Left != null)
	    {
	        foreach (var leftValue in Left.InOrderTraversal())
	        {
	            yield return leftValue;
	        }
	    }
	
	    yield return Value;
	
	    if (Right != null)
	    {
	        foreach (var rightValue in Right.InOrderTraversal())
	        {
	            yield return rightValue;
	        }
	    }
	}

	// 后序遍历：右 -> 根 -> 左
	public IEnumerable<int> PostOrderTraversal()
{
    if (Left != null)
    {
        foreach (var leftValue in Left.PostOrderTraversal())
        {
            yield return leftValue;
        }
    }

    if (Right != null)
    {
        foreach (var rightValue in Right.PostOrderTraversal())
        {
            yield return rightValue;
        }
    }

    yield return Value;
}

}

class Program
{
    static void Main()
    {
        // 构建一棵二叉树
        TreeNode root = new TreeNode(1);
        root.Left = new TreeNode(2);
        root.Right = new TreeNode(3);
        root.Left.Left = new TreeNode(4);
        root.Left.Right = new TreeNode(5);
        root.Right.Left = new TreeNode(6);
        root.Right.Right = new TreeNode(7);

        // 使用深度优先遍历二叉树
        Console.WriteLine("DFS Traversal (Pre-order):");
        foreach (int value in root.PreOrderTraversal())
        {
            Console.WriteLine(value);
        }
    }
}

输出：

DFS Traversal (Pre-order):
1 2 4 5 3 6 7
DFS Traversal (In-order):
4 2 5 1 6 3 7
DFS Traversal (Post-order):
4 5 2 6 7 3 1

二叉树的形状：
在这里插入图片描述

4.4 迭代器的工作原理

在后台，由编译器生成的枚举器类是包含4个状态的状态机。

  • Before 首次调用 MoveNext 的初始状态。
  • Running 调用MoveNext后进入这个状态。在这个状态中，枚举器检测并设置下一项的位置。在遇到yield return、yield break 或在迭代器体结束时，退出状态。
  • Suspended 状态机等待下次调用 MoveNext 的状态。
  • After 没有更多项可以枚举。
    在这里插入图片描述

好了，以上就是对 C# 当中枚举器、可枚举类以及迭代器的介绍。如有收获，记得一键三连呐。

最后，给各位道友介绍一下使用国外虚拟卡开通一些国外服务的渠道，当前我在用的是 wildcard，使用我的注册邀请码 IOQ1YDHH 注册，能得 2 美刀呢。能抵消一部分的开卡费用。自己买个 Github Copilot 、ChatGPT Plus 简直不要太香。

友恒
关注
专栏目录
C# 图解教程 第5版 —— 第19章 枚举器和迭代器
zheliku的博客
12-18 1270
​ 编译器得到有关枚举项的描述后，会构建包含所有需要的方法（MoveNext）和属性（Current）实现的枚举器类，产生的类被嵌套包含在声明迭代器的类中。​ 可枚举类是指实现了 IEnumerable 接口的类，该接口只有一个成员——GetEnumerator，返回对象的枚举器。​ 对于有枚举器的类型而言，我们使用 GetEnumerator 方法来获取其拥有的枚举器，实现该方法的类型称为。​ 迭代器块描述了希望编译器为我们创建的枚举器类的行为，其中的代码描述了如何枚举元素。或不实现，来让类不可枚举。
C#图解教程 第十八章 枚举器和迭代器
weixin_38166793的博客
03-14 432
枚举器和迭代器 枚举器和可枚举类型 foreach语句 IEnumerator接口 使用IEnumerable和IEnumerator的示例 泛型枚举接口迭代器 迭代器块使用迭代器来创建枚举器使用迭代器来创建可枚举类型 常见迭代器模式产生多个可枚举类型将迭代器作为属性迭代器实质 枚举器和迭代器 枚举器和可枚举类型 第12章中，我们看到可以用foreach语句遍历数...
C#图解教程（第四版）小笔记——枚举器和迭代器
只要你是蓝吹我们就是朋友
09-27 195
枚举器 实现枚举器（enumerator）的对象称为可枚举类型（enumerable type 或enumerable）。 调用可枚举类型的GetEnumerator方法获取枚举器。 foreach原理： ①调用GetEnumerator方法获取enumerable的枚举器。 ②从枚举器请求每一项并把它作为迭代变量，代码可以读取变量但是不能改变。 IEnumerator接口和IEnumerable接口 实现IEnumerator接口的枚举器包含三个函数成员： Current 只读属性，返回object类
C#中的枚举器和迭代器
weixin_66598341的博客
04-03 788
主要介绍了可枚举类型、枚举器以及迭代器之间的关系，案例包括可枚举类和枚举器的使用，以及如何使用迭代器创建可枚举类型和枚举器。
C#图解教程（第四版)_18章枚举器和迭代器：EnumeratorSampleP340
只会写HelloWorld的专栏
01-14 133
using System; using System.Collections; namespace Chapter18EnumeratorSampleP340 { class ColorEnumerator:IEnumerator { string[] _colors; int _position = -1; public ColorEnumerator(string[] theColors)// 构造函数 { .
C#4.0图解教程 - 第20章 枚举数和迭代器
weixin_30591551的博客
01-29 78
20.1 枚举数和可枚举类型 在.NET中获取一个对象枚举数的标准方法是调用对象的 GetEnumerator 方法。实现 GetEnumerator 方法的类型叫做可枚举类型（enumerable type或enumerable）。数组是可枚举类型。 20.2 使用 IEnumerator 接口 IEnumerator： 接口包含3个函数成员：Current、Move...
C#图解教程（第四版）小笔记（总）
只要你是蓝吹我们就是朋友
09-27 1058
基础 字符串格式说明符：由索引号，对其说明符、各式字段3个部分组成 索引号 尝试引用超出替换值列表长度以外的索引时，不会产生编译错误，但会产生运行时错误（异常） 对齐说明符 可选，+（默认，可不写）表示右对齐，-号表示左对齐 整数表示使用字符的最少数量 格式字段 9个内置格式说明符： C、c：货币，货币符号取决于程序所在PC的区域设置 D、d：十进制 F、f：定点 G、g：常规，在没有指定说明符的情况下，会根据值转换为定点或科学记数法表示的紧凑形式 X、x：十六进制 N、n：数字，每三个数字间有逗号（
C#迭代器——由foreach说开去
O213的博客
03-24 7193
C#迭代器——由foreach说开去 IEnumerable和IEnmerator yield retun StartCoroutine
C#图解教程(C#5.0)第4版笔记
duling2的博客
05-16 929
执行环境称为CLR: Common Language Runtime 公共语言运行库 基类库BCL 超集 框架类库FCL CIL common intermediate language 公共中间语言 以前叫IL 或 MSIL 程序集要么是可执行的，要么是DLL .NET写的代码由CLR来托管代码 所有C#关键字全部由小写字母组成，但是.NET类型名使用Pascal大小写约定 第29页 C#的关键字,C#的上下文关键字 程序的入口点 static void Main(){} Console
图解c#2012代码
06-05
自定义迭代器使用`yield`关键字返回一系列值，使开发者能够创建自己的枚举行为，例如在遍历复杂数据结构时。 8. **扩展方法（Extension Methods）** 扩展方法允许你在不修改现有类的情况下向其添加新方法。这对于...
c#中的功能优势
red_redemption的博客
09-25 1801
装箱和拆箱只适用于值类型和引用类型之间的转换。和父子类的类型转换没关系，如果从object转为class类对象，不涉及装箱拆箱// 装箱：值类型转换为引用类型// 拆箱：从引用类型转换回值类型把值类型变为引用类型才是装箱，把引用类型返回为原始的值类型，才是拆箱引用类型更加通用，更像c#中数据处理 的箱子，值类型更加本质，所以拆箱就是还原初始无论是将子类转换为父类（向上转换），还是将父类转换为子类（向下转换），都不会涉及值类型与引用类型之间的转换。向上转换（子类转父类）
每日英语听力 Day12
weixin_42019995的博客
10-01 1187
【代码】每日英语听力 Day12。
C# 无边框窗体，加阴影效果、多组件拖动、改变大小等功能完美实现优化版效果体验
无线智能模块 可视DIY智能专家
10-01 395
- 无边框窗体拖动（支持定义多组件拖动窗体） - 无边框窗体缩放（组件不被遮挡） - 拖动半透明效果（按下鼠标拖动时，松开恢复） - 窗体四周边框特效 - 限制窗体右侧和底部到屏幕外（根据需要设置） - 右键增加 访问历史记录（本实例没有使用多标签组件，自身实现页面浏览） - 一键锁屏（相当于win+L） - 一键置顶（topMost） - 最大化、最小化、关闭（图标更换） - 标题栏渐变效果（重绘）
掌握C#核心概念：类、继承、泛型等
qq_45728381的博客
10-02 892
C# 是一门功能强大且灵活的面向对象编程语言，它结合了许多现代编程语言的特点和特性。无论你是编程新手，还是有经验的开发者，理解C#中的核心概念都是非常重要的。本文将介绍C#中的类与对象、构造函数和析构函数、方法的重载与重写、继承与多态等基础知识，并为每个主题提供简要的解释和示例代码。
C#基础语法
qq_45728381的博客
10-01 1198
函数是用于组织和重用代码的基本单元。定义一个函数// 定义一个简单的函数，它接收两个整数并返回它们的和调用函数// 输出 15带有返回类型为 void 的方法");// 输出 "Hello, World!本教程简单介绍了C#编程的基本概念，包括数据类型、运算符、条件语句、循环结构以及函数定义。通过这些基础知识，你可以开始编写简单的C#程序，并为更复杂的编程任务奠定基础。
掌握 C# 中的委托与事件机制
最新发布
qq_45728381的博客
10-02 1201
委托是一种类型安全的函数指针，可以用于引用一个或多个方法。通过委托，可以将方法作为参数传递给其他方法，从而实现回调和灵活的行为封装。委托的定义类似于定义方法签名，它指定了可以被引用的方法的返回类型和参数列表。// 定义一个委托// 使用委托// 调用委托// 将方法赋值给委托");// 输出：Hello, Delegates!在上面的示例中，是一个委托类型，它可以引用任何具有void返回类型且接受string参数的方法。我们将方法赋值给委托实例，并通过委托调用该方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值