第19章 枚举器和迭代器 笔记

最新推荐文章于 2025-08-05 20:04:56 发布
最新推荐文章于 2025-08-05 20:04:56 发布
阅读量650 收藏 6
点赞数 7
CC 4.0 BY-SA版权
分类专栏： 图解C#教程 第五版 笔记 文章标签： 笔记 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/z2014z/article/details/149935391

第19章 枚举器和迭代器 25.08.04

19.1 枚举器和可枚举类型

使用 foreach 语句

下面是使用 foreach 语句遍历数组的示例。

int[] arr1 = { 10, 11, 12, 13 }; // Define the array.
foreach (int item in arr1) // Enumerate the elements.
    Console.WriteLine($"Item value: { item }");

// output
Item value: 10
Item value: 11
Item value: 12
Item value: 13

数组可以使用这种方式访问，是因为：数组提供了枚举器对象。枚举器知道数组中元素的次序，并依次返回数组中的元素。

对于有枚举器的类型而言，使用 GetEnumerator 方法来获取其拥有的枚举器，实现该方法的类型称为可枚举类型。数组就是可枚举类型。

在这里插入图片描述

foreach 结构设计用来和可枚举类型一起使用，如下行为会被执行：

  1. 调用 GetEnumerator 方法获取对象的枚举器。
  2. 从枚举起中请求每一项并作为迭代变量（可读不可写）。
foreach( Type VarName in EnumerableObject )
{
	// ...
}

19.2 IEnumerator 接口

实现了 IEnumerator 接口的枚举器包含 3 个函数成员：Current、MoveNext、Reset

1.Current：返回序列中当前位置项的属性。

  • 为只读属性。

  • 返回 object 类型的引用。

2.MoveNext ：是将枚举器位置前进到集合中下一项的方法，返回布尔值。

  • 如果新的位置有效，返回 true。
  • 如果新的位置无效，返回 false。

3.Reset：将位置重置为原始状态。

  • 枚举器的原始位置在序列中的第一项之前，因此 MoveNext 必须在第一次使用 Current 之前调用。

在这里插入图片描述

在编写 foreach 循环的时候，C# 编译器将生成与下面十分类似的代码（以 CIL 的形式）。

static void Main()
{
    int[] arr1 = { 10, 11, 12, 13 }; // Create an array.
    // Get and store the enumerator.
    IEnumerator ie = arr1.GetEnumerator();
    // Move to the next position.
    while ( ie.MoveNext() )
    { 
        // Get the current item.
        int item = (int) ie.Current;
        Console.WriteLine($"Item value: { item }"); // Write it out.
    }
}

// output
Item value: 10
Item value: 11
Item value: 12
Item value: 13

19.3 IEnumerable 接口

可枚举类是指实现了 IEnumerable 接口的类，该接口只有一个成员–GetEnumerator，返回对象的枚举器。

在这里插入图片描述

using System.Collections;
// Implements the IEnumerable interface
class MyClass : IEnumerable
{
    //  Returns an object of type IEnumerator
    public IEnumerator GetEnumerator { ... }
    // ... 
}

使用 IEnumerable 和 IEnumerator 的示例

using System;
using System.Collections;
class ColorEnumerator : IEnumerator
{
    string[] Colors;
    int Position = -1;
    public ColorEnumerator( string[] theColors ) // Constructor
    {
        Colors = new string[theColors.Length];
        for ( int i = 0; i < theColors.Length; i++ )
            Colors[i] = theColors[i];
    }
    public object Current // Implement Current.
    {
        get
        {
            if ( Position == -1 )
                throw new InvalidOperationException();
            if ( Position >= Colors.Length )
                throw new InvalidOperationException();
            return Colors[Position];
        }
    }
    public bool MoveNext() // Implement MoveNext.
    {
        if ( Position < Colors.Length - 1 )
        {
            Position++;
            return true;
        }
        else
            return false;
    }
    public void Reset() // Implement Reset.
    {
        Position = -1;
    }
}

class Spectrum : IEnumerable
{
    string[] Colors = { "violet", "blue", "cyan", "green", "yellow", "orange", "red" };
    public IEnumerator GetEnumerator()
    {
        return new ColorEnumerator( Colors );
    }
}
class Program
{
    static void Main()
    {
        Spectrum spectrum = new Spectrum();
        foreach ( string color in spectrum )
            Console.WriteLine( color );
    }
}

// output
violet
blue
cyan
green
yellow
orange
red

19.4 泛型枚举接口

使用 C# 泛型和非泛型的方式相差不大。

本质区别如下：

  • 对于非泛型接口形式：
    • IEnumerable 接口的 GetEnumerator 方法返回实现 IEnumerator 的枚举器类实例。
    • 实现 IEnumerator 的类实现了 Current 属性，返回 object 类型的引用，然后将其转化为对象的实际类型。
  • 对于泛型接口形式：
    • IEnumerable 接口的 GetEnumerator 方法返回实现 IEnumerator 的枚举器类实例。
    • 实现 IEnumerator 的类实现了 Current 属性，返回实际类型的实例，而不是 object 基类的引用。
    • 实际上泛型接口的声明是协变的，即 IEnumerable 和 IEnumerator，因此这些接口的对象可以是派生的类型。

泛型版本简单易用，但其结构略显复杂。

在这里插入图片描述

19.5 迭代器

可枚举类和枚举器在 .NET 集合类中被广泛使用，从 C# 2.0 版本开始提供了创建枚举器和可枚举类型更简单的方式，将这种结构称为迭代器。

在下面这个示例中：

  • 迭代器返回一个泛型枚举器，该枚举器返回 3 个 string 类型的项。
  • yield return 语句声明这是枚举中的下一项。
// 返回泛型枚举器，它返回的是字符串对象
public IEnumerator<string>BlackAndWhite() // 版本1
{
    yield return "black";  //yield return
    yield return "gray";   //yield return
    yield return "white";  //yield return
}

下面的方法声明了另一个版本，输出结果与上面相同。

// 返回泛型枚举器，它返回的是字符串对象
public IEnumerator<string>BlackAndwhite()  // 版本2
{
    string[]theColors "black","gray","white"}
    for (int i=0;i theColors.Length;i++)
        yield return theColors[i];       //yield return
}

枚举器不会一次返回所有的元素，而是每次访问 Current 属性时返回一个新值。

19.5.1 迭代器块

迭代器块是有一个或多个 yield 语句的代码块，可以是如下任意一种代码块：

  • 方法主体。
  • 访问器主体。
  • 运算符主体。

迭代器块描述了希望编译器为我们创建的枚举器类的行为，其中的代码描述了如何枚举元素。

  1. yield return：指定序列中要返回的下一项。
  2. yield break：指定在序列中没有其他项。

编译器得到有关枚举项的描述后，会构建包含所有需要的方法（MoveNext）和属性（Current）实现的枚举器类，产生的类被嵌套包含在声明迭代器的类中。

根据指定的返回类型，可以让迭代器产生枚举器或可枚举类型

// 产生枚举器的迭代器
public IEnumerator<string> IteratorMethod()
{
    // ...
    yield return ...;
}

// 产生可枚举类型的迭代器
public IEnumerable<string> IteratorMethod()
{
    // ...
    yield return ...;
}

19.5.2 使用迭代器来创建枚举器

class MyClass
{
    public IEnumerator<string> GetEnumerator()
    { return BlackAndWhite(); } // Returns the enumerator

    // Returns an enumerator
    public IEnumerator<string> BlackAndWhite() // Iterator
    {
        yield return "black";
        yield return "gray";
        yield return "white";
    }
}
class Program
{
    static void Main()
    {
        MyClass mc = new MyClass();
        // Use the instance of MyClass.
        foreach (string shade in mc)
            Console.WriteLine(shade);
    }
}

// output
black
gray
white

图中左边演示了返回类型是 IEnumerator。

图中右边演示了它有一个嵌套类实现了 IEnumerator。

在这里插入图片描述

19.5.3 使用迭代器来创建可枚举类型

本节例子使用迭代器来创建可枚举类型，而不是枚举器。

  • BlackAndWhite 迭代器方法返回 IEnumerable 而不是 IEnumerator。
  • MyClass 首先调用 BlackAndWhite 方法获取可枚举类型对象，然后调用该对象的 GetEnumerator 方法来获取结果，从而实现 GetEnumerator 方法。
class MyClass
{
    public IEnumerator<string> GetEnumerator()
    {
        IEnumerable<string> myEnumerable = BlackAndWhite(); // Get enumerable.
        return myEnumerable.GetEnumerator(); // Get enumerator.
    } 
    // Returns an enumerable
    public IEnumerable<string> BlackAndWhite()
    {
        yield return "black";
        yield return "gray";
        yield return "white";
    }
}

class Program
{
    static void Main()
    {
        MyClass mc = new MyClass();
        // Use the class object.
        foreach (string shade in mc)
            Console.Write($"{ shade } ");
        // Use the class iterator method.
        foreach (string shade in mc.BlackAndWhite())
            Console.Write($"{ shade } ");
    }
}

// output
black gray white black gray white
  • 图中左边演示了返回类型是 IEnumerable。
  • 图中右边演示了它有一个嵌套类实现了 IEnumerator 和 IEnumerable。

在这里插入图片描述

编译器生成的类是可枚举类型并返回一个枚举器。编译器还生成了方法 BlackAndWhite，返回可枚举对象

19.6 常见迭代器模式

  1. 实现返回枚举器的迭代器。

    通过实现 GetEnumerator 方法让类可枚举，它返回由迭代器返回的枚举器。

  2. 实现返回可枚举类型的迭代器。

    实现 GetEnumerator 来让类本身可枚举；或不实现，来让类不可枚举。

常见的迭代器模式

// 枚举器的迭代器模式
class MyClass
{
    public IEnumerator<string> GetEnumerator()
    {
        return IteratorMethod();
    }

    public IEnumerator<string> IteratorMethod()
    {
        ...
        yield return ...;
    }
    ...
}

Main
{
    MyClass mc = new MyClass();

    foreach( string x in mc )
        ...
}

/// 可枚举类型的迭代器模式
class MyClass
{
    public IEnumerator<string> GetEnumerator()
    {
        return IteratorMethod().GetEnumerator();
    }

    public IEnumerable<string> IteratorMethod()
    {
        ...
        yield return ...;
    }
    ...
}

Main
{
    MyClass mc = new MyClass();

    foreach( string x in mc )
        ...

    foreach( string x in mc.IteratorMethod() )
        ...
}

19.7 产生多个可枚举类型

Spectrum 类有两个可枚举类型的迭代器，但类本身不可枚举，因为没有实现 GetEnumerator 方法。

using System;
using System.Collections.Generic;

class Spectrum
{
    string[] colors = { "violet", "blue", "cyan", "green", "yellow", "orange", "red" };
    
    public IEnumerable<string> UVtoIR()
    {
        for (int i = 0; i < colors.Length; i++)
            yield return colors[i];
    }
    
    public IEnumerable<string> IRtoUV()
    {
        for (int i = colors.Length - 1; i >= 0; i--)
            yield return colors[i];
    }
}

class Program
{
    static void Main()
    {
        Spectrum spectrum = new Spectrum();
        
        foreach (string color in spectrum.UVtoIR())
            Console.Write($" {color} ");
        Console.WriteLine();
        
        foreach (string color in spectrum.IRtoUV())
            Console.Write($" {color} ");
        Console.WriteLine();
    }
}

// output
violet blue cyan green yellow orange red
red orange yellow green cyan blue violet

19.8 将迭代器作为属性

本示例演示两个方面的内容：

  1. 使用迭代器产生两个枚举器的类。
  2. 演示迭代器如何实现为属性，而不是方法。

这段代码声明了两个属性来定义两个不同的枚举器。GetEnumerator 方法根据 _listFromUVtoIR 布尔变量的值返回两个枚举器中的一个。如果 _listFromUVtoIR 为 true，则返回 UVtoIR 枚举器；否则，返回 IRtoUV 枚举器。

using System;
using System.Collections.Generic;

class Spectrum 
{
    private bool _listFromUVtoIR;
    private string[] colors = { "violet", "blue", "cyan", "green", "yellow", "orange", "red" };

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

    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 (int 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($"{color} ");
        Console.WriteLine();

        foreach (string color in startIR)
            Console.Write($"{color} ");
        Console.WriteLine();
    }
}

19.9 迭代器的实质

有关迭代器的其他重要事项：

  • 迭代器需要 System.Collections.Generic 命名空间，因此需要使用 using 指令进行引入。
  • 在编译器生成的枚举器中，不支持 Reset 方法。Reset 是接口需要的方法，所以实现了它，但调用时总是抛出 System.NotSupportedException 异常。

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

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

在这里插入图片描述

Python学习笔记 - 探索枚举和Zip的应用
Mr数据杨
12-09 213
枚举（Enumerate）和Zip作为Python内置函数，在数据处理和编程中起着重要作用。枚举使得在遍历可迭代对象时能够轻松获取元素的索引与值，而Zip则将多个序列逐项打包成元组，提供了简便的多组数据管理方式。两者结合使用，更适合复杂数据结构的处理需求，例如多维数据的对齐、数据分析中的进度跟踪等。通过这些功能，能实现更加简洁和高效的代码结构，减少额外的逻辑编写，提升程序可读性。枚举和Zip的应用场景涵盖了数据标记、任务管理、数据分析等多个领域。
Python学习笔记31：迭代技术
梦幻天空
05-12 660
Python学习笔记31：迭代技术 本系列文章的代码都存放在Github项目：python-learning-notes。 这一部分内容是《Fluent Python》目前为止最长的篇幅，我也花了大半天时间来阅读，内容的确庞杂，所以在提炼整理上可能会有所疏漏，请多包涵。 迭代技术无疑在Python中占有相当的地位。平时我们在写代码的时候，大多数时间也是话费在for或者foreach之类的循环语句上，而Python更进一步，在语言结构中直接整合了迭代技术，让我们可以更容易地在不同类型间使用类似的简单语
PythonCookBook笔记——迭代器与生成器
weixin_30650039的博客
09-04 117
迭代器与生成器 迭代是Python最强大的功能之一，虽然看起来迭代只是处理序列中元素的一种方法，但不仅仅如此。 手动遍历迭代器 想遍历但不想使用for循环。 使用next()方法并在代码中捕获StopIteration异常。 StopIteration用来指示迭代的结尾，也可以通过返回指定结尾。 l = next(iterator, None) 代理迭代 构建了一个自定义容器对象，想在这...
(delphi11最新学习资料) Object Pascal 学习笔记---第10章第5节（实现类的枚举支持）
langfengyl的专栏
05-02 415
目前缺少的是子控件的枚举。完成这个步骤以后（我将在第二个实际示例中向您展示如何完成），编译器就可以解析for-in循环，其中目标是我们类，单独元素必须是枚举器的。尽管最明显的示例是包含元素列表的类，但从技术角度来看，此功能是相当开放的。​ 虽然说并不是严格必要，但把枚举器支持类作为嵌套类型来实现似乎是个好主意（这是第 7 章中涉及的一种语言特性），因为单独使用用于枚举的特定类型毫无意义。循环，其中的目标是我们的类，而各个元素必须与枚举器的。的方法，该方法返回一个类（实际的枚举类），并使用。
第19章 枚举类型
yuexiaqiying的博客
03-07 346
枚举在Java中是一个小功能，它所带来的价值是在某些方面可以优雅的解决某些问题。
C++_Primer_学习笔记_第十九章（特殊工具和技术）
YRC的博客
08-03 316
第十九章（特殊工具与技术） /1.控制内存分配 1).不能直接应用标准内存管理机制。 某一些应用程序需要自定义内存分配的的细节，比如使用关键字new将对象放置在特定的内存空间中。 为了实现这一个目的，需要重载new和delete运算符，来控制内存分配的过程。 //1.重载new和delete 1).尽管说是重载，但是重载它们和重载其他的运算符过程大不相同。 2).了解new和delete表达式的工作机理。 { // ---------------new string *sp = new
C++ Primer 学习笔记 第十九章 特殊工具与技术
tus00000的博客
05-08 347
某些应用程序对内存分配有特殊需求，如使用new将对象放置在特定的内存空间中，为实现它，应用程序需要重载new和delete。 new实际执行步骤： 1.new表达式调用operator new（或operator new[]）的标准库函数，分批一块足够大的、原始的、未命名的内存空间以便存储特定类型对象（或对象的数组）。 2.编译器运行构造函数构造对象。 3.对象被分配了空间并构造完成，返回指向它的...
C++ primer plus笔记 --- 第4章、复合类型
qq_19432525的博客
05-04 470
string 类,必须包含头文件string，string类位于名称空间中。C++ 11字符串初始化,注意C/C++两种风格// C语言风格// C语言风格// C++风格// C++风格// C++风格C语言风格不能将一个数组赋值给另一个数组，但可以将一个string对象赋值给另一个string对象。结构（Structure）是一种用户自定义的数据类型，在程序中用于组织和存储相关的变量。结构包含一组不同的变量，这些变量可能是不同的数据类型，例如整型、浮点型、字符型等。在C++中，结构通过。
Java核心技术卷一第九章读书笔记
GatesMa's blog
07-31 726
文章目录9.1 Java集合框架9.2 具体的集合9.3 映射9.4 视图与包装器（没看，不想看）9.5 算法9.6 遗留的集合 9.1 Java集合框架 与现代的数据结构类库的常见情况一样，Java集合类库也将接口(interface)与实现(implements分离 队列通常有两种实现方式：一种是使用循环数组（ArrayDeque），一种是使用链表（LinkedList） Java类库没有名...
C#图解教程读书笔记（三 类型转换、泛型、协变/逆变、迭代器、异步编程）
Ha啤酒来大杯的博客
08-10 467
提要，此文章并不会记录过于基础的东西，只会记录个人认为比较重要的概念以及实用的代码，如果您是新手强烈建议阅读实体书，自己一步一步敲一遍 第十七章 转换 显示转换 例如高位数字转低位数字需要进行显示转换，此时会出现数据丢失问题，可以利用checked/unchecked来控制是否抛出overflow异常。其中checked/unchecked可以作用于表达式和代码片段。 引用转换的隐式转换 ：1、所有引用类型可以被隐式转换为object。2、任何接口可以被隐式转换为继承的接口 3、任何类可以隐式转换为继.
Java核心技术· 卷一（11版）笔记（第7-9章）
weixin_43647460的博客
11-01 339
Java中的异常、断言和日志是常用的调试和错误处理工具。异常是在代码执行过程中发生不可预测的错误时，程序会抛出一个异常来中断当前的执行流程，以防止更严重的错误发生。Java中的异常分为可检查异常（checked exception）和运行时异常（runtime exception）。可检查异常需要在方法的声明中被显式地声明或捕获，而运行时异常则不需要。常见的Java异常类包括：NullPointerException、ArithmeticException、ArrayIndexOutOfBoundsExce
Java核心技术· 卷二（11版）笔记（第1-4章）
weixin_43647460的博客
11-10 411
Java8 中的流库是一个新的API，它提供了一种简便的方式来对数据进行操作和处理。它包括了一些基础的接口和类，可以用来处理集合，数组等数据结构。下面是 Java8 中的流库的一些主要接口和类：Stream：流的主要接口，提供了一些常用的方法，如 filter、map、reduce 等，用于对数据进行操作。Optional：可选值类型，用于处理缺失的值，防止出现 NullPointerException。Collector：收集器，用于将流中的元素收集到指定的集合中，也可以用于分组、分区等操作。Splite
【笔记】ROS1｜5 ARP攻击Turtlebot3汉堡Burger并解析移动报文【旧文转载】
shandianchengzi的博客
08-04 876
本文介绍了如何使用ARP攻击技术干扰Turtlebot3汉堡机器人的ROS通信。作者首先讲解了ARP协议的基本原理和攻击依据，然后通过实验演示了如何利用arpspoof工具实施ARP欺骗攻击，包括干扰普通主机上网和小车与控制机的通信。文章提供了详细的实验步骤和思考题，并建议读者在虚拟机环境下进行实践。实验结果显示，通过持续发送虚假ARP响应包可以成功劫持网络通信，开启IP转发后虽能恢复但会降低网速。最后作者还演示了如何解析被攻击机器人的移动控制报文。
学习笔记090——Ubuntu 中 UFW 防火墙的使用
code__bee的博客
08-01 422
【代码】学习笔记090——Ubuntu 中 UFW 防火墙的使用。
PYQT学习笔记：signal 和 slot（信号与槽）
最新发布
qq_52251819的博客
08-05 440
通过 button.clicked.connect(on_button_clicked) 语句将信号与槽关联。当按钮被点击（发出 clicked 信号）时，执行 on_button_clicked 函数。在示例中，on_button_clicked() 就是一个槽函数，用于处理按钮点击事件。在示例中，button.clicked 就是一个信号，表示 “按钮被点击” 这个事件。每当点一次“统计”按钮，终端就会打印一次“按钮被点击了”支持一个信号连接多个槽，或多个信号连接同一个槽。槽是用于接收信号并处理的。
电力系统分析学习笔记
zxjiaya的博客
08-02 635
本文总结了电力系统分析的核心知识点：1)电力线路电容特性分析，指出电缆线路电容比架空线路大；2)三相功率关系推导，包含线/相电压转换和阻抗计算；3)标幺值计算法原理，强调基准量选择方法；4)变压器阻抗折算的简化技巧，建议采用平均额定电压；5)两种标幺值计算方法对比。重点阐述了电容特性、功率方程、标幺值转换等电力系统分析基础理论，为后续短路计算等应用提供理论支撑。
LLM微调笔记
qq_44899247的博客
08-02 238
微调相当于用少量特定数据集在预训练模型（如 Qwen、DeepSeek 等）上进一步训练，让模型更贴合新数据集的内容。微调主要分为全量微调和参数高效微调（PEFT），其中 PEFT 中最常用的是 LoRA：其核心是在模型关键层（如注意力层）的高秩权重矩阵中插入两个低秩矩阵（A 和 B），训练时仅更新这两个低秩矩阵的参数（参数量远小于原矩阵，例如原矩阵维度为 d×d 时，低秩矩阵为 d×r 和 r×d，r 远小于 d），以此大幅降低计算成本。适合自己从零开始看的llm微调知识点。
《C语言程序设计》笔记p7
2401_83507683的博客
08-04 774
struct 结构体名 变量名1 = {成员1的初始值,成员2的初始值,...};struct 结构体名 变量名2 = {.成员变量名1 = 初始值1, .成员变量名2 = 初始值2,...};//C99及以上// 定义一个学生类型的变量zhang3,// 定义100个学生类型的数组 class1;综合示例// 姓名int age;// 年龄// 身高// 定义一个学生类型的变量zhang3,// 定义100个学生类型的数组 class1;return 0;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值