C#枚举器，手动实现枚举器，可枚举集合，枚举器操作，迭代器

最新推荐文章于 2024-05-08 10:06:13 发布
最新推荐文章于 2024-05-08 10:06:13 发布
阅读量404 收藏
点赞数
文章标签： c# class null object 编译器 string

在C#语言中提供 foreach 查询操作，foreach 大大的简化了要编写的代码，但是foreach 只能用来遍历一个可枚举的集合（enumable），可枚举的集合就是实现了System.Collections.IEnumerable接口的一个集合。

 

但是foreach 返回的是可枚举对象的一个只读集合，不可以通过foreach 来修改可枚举对象。

 

简单的一个例子：

 int[] number_array = new int[] { 1,2,3,4,5,6};

 foreach (int k in number_array)
 {
     Console.WriteLine(k);
 }

int 类型，继承了IEnumerable<T> 接口，所有可以用foreach 来遍历。如果我们自己写的一个类，没有实现IEnumerable<T> 接口，用foreach 就不能进行迭代了，编译器会报错。

 

例如：

自己写的一个类：

 class Student: IComparable<Student>
    {
        public Student()
        {
            // nothing
        }

        private int age;

        public int Age
        {
            get { return this.age;}
            set { this.age = value; }
        }

        public int CompareTo(Student other)
        {
            //throw new NotImplementedException();
            if (this.age == other.age)
            {
                return 0;
            }
            else if (this.age < other.age)
            {
                return -1;
            }
            else
            {
                return 1;
            }
        }
    }

 

这个类实现了 IComparable<T> 接口，但是没有实现 IEnumerable<T> 接口，不能用foreach 遍历。

下面的代码对这个没有实现 IEnumerable<T> 接口的类进行foreach 遍历结果发生编译错误。

 

 //Student[] student=new Student[5];
 //student.test();
 //foreach (Student t in student)
 //{
               
 //}

下面我们将自己手动的给上面那个简单的类实现枚举器，通过foreach来遍历这个类。

 

在 IEnumerable接口中，包括一个GetEnumerator的方法：

IEnumerator GetEnumertor(); 

 

这个方法返回一个枚举器对象。

IEnumerator 接口中规定了以下方法和属性：

object Current {get;}
bool MoveNext();
void Reset();

最初枚举器的指针指向枚举集合的第一个元素的前面，在获取 Current之前先要调用MoveNext() 使指针指向下一个元素。

 

以上所说的接口， 都有他们对应的泛型接口，在接下来的实现中，都会使用泛型接口。

当我们给要枚举的类实现了IEnumerable<T>接口后，foreach语句会自动的让生成一个枚举器，并通过枚举器中的Current, MoveNext等获取下一个数据，这一切过程对于foreach的使用者都是透明的。

 

下面，先给出本实例的所有代码，然后进行分析讲解。

所有原码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EnumerableTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] number_array = new int[] { 1,2,3,4,5,6};

            foreach (int k in number_array)
            {
                Console.WriteLine(k);
            }

            //Student[] student=new Student[5];
            student.test();
            //foreach (Student t in student)
            //{
               
            //}

            Student[] student = new Student[5];
            student[0] = new Student();
            student[0].Age = 12;
            student[1] = new Student();
            student[1].Age = 13;
            student[2] = new Student();
            student[2].Age = 74;
            student[3] = new Student();
            student[3].Age = 34;
            student[4] = new Student();
            student[4].Age = 32;

            Console.WriteLine("/");

            Sector<Student> sector = new Sector<Student>(student);
            foreach (Student t in sector)
            {
                Console.WriteLine(t.Age);
            }
        }
    }

    class Sector<T> : IEnumerable<T>
        where T : IComparable<T>
    {
        T[] student;

        public Sector(T[] t)
        {
            student = t;
        }

        public IEnumerator<T> GetEnumerator()
        {
            return new SectorEnumator<T>(student);
            //throw new NotImplementedException();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            //throw new NotImplementedException();
            return null;
        }
    }

    class SectorEnumator<T> : IEnumerator<T>
        where T : IComparable<T>
    {
        private T[] student;
        private Queue<T> MyQueue;
        private T currentItem;

        public SectorEnumator(T[] s)
        {
            this.student = s;
        }

        public T Current
        {
            get { return this.currentItem; }
        }

        public void Dispose()
        {
            // simply do nothing
            //throw new NotImplementedException();
        }

        object System.Collections.IEnumerator.Current
        {
            get { throw new NotImplementedException(); }
        }

        public bool MoveNext()
        {
            if (this.MyQueue == null)
            {
                MyQueue = new Queue<T>();
                populate(student);
            }
            if (this.MyQueue.Count > 0)
            {
                this.currentItem = MyQueue.Dequeue();
                return true;
            }
            return false;
            //throw new NotImplementedException();
        }

        public void Reset()
        {
            //throw new NotImplementedException();
            MyQueue.Clear();
            populate(student);
        }

        private void populate(T[] s)
        {
            int num = s.Length;
            for (int i = 0; i < num; i++)
            {
                MyQueue.Enqueue(s[i]);
            }
        }
    }

    class Student: IComparable<Student>
    {
        public Student()
        {
            // nothing
        }

        private int age;

        public int Age
        {
            get { return this.age;}
            set { this.age = value; }
        }

        public int CompareTo(Student other)
        {
            //throw new NotImplementedException();
            if (this.age == other.age)
            {
                return 0;
            }
            else if (this.age < other.age)
            {
                return -1;
            }
            else
            {
                return 1;
            }
        }
    }
}
 

首先，我们定义了一个Student 类，并实现了IComparable<T> 接口，我们程序的目的就是在使用Student类的时候，可以通过foreach 来遍历Student数组中的每个成员，但是默认情况下Student类并没有实现IEnumberable<T>接口，所有在直接用foreach 遍历的时候会编译报错。

 

为了遍历Student类，我们手动实现了一个枚举器。

class SectorEnumator<T> : IEnumerator<T>
        where T : IComparable<T>
    {
        private T[] student;
        private Queue<T> MyQueue;
        private T currentItem;

        public SectorEnumator(T[] s)
        {
            this.student = s;
        }

        public T Current
        {
            get { return this.currentItem; }
        }

        public void Dispose()
        {
            // simply do nothing
            //throw new NotImplementedException();
        }

        object System.Collections.IEnumerator.Current
        {
            get { throw new NotImplementedException(); }
        }

        public bool MoveNext()
        {
            if (this.MyQueue == null)
            {
                MyQueue = new Queue<T>();
                populate(student);
            }
            if (this.MyQueue.Count > 0)
            {
                this.currentItem = MyQueue.Dequeue();
                return true;
            }
            return false;
            //throw new NotImplementedException();
        }

        public void Reset()
        {
            //throw new NotImplementedException();
            MyQueue.Clear();
            populate(student);
        }

        private void populate(T[] s)
        {
            int num = s.Length;
            for (int i = 0; i < num; i++)
            {
                MyQueue.Enqueue(s[i]);
            }
        }
    }

在MOveNext() 中，如果这个枚举器的MyQueue为null，则new 一个Queue, 用MyQueue存放给枚举器传进来的对象数组。每一次MoveNext() 都会造成一个对象出队。

 

然后给一个类实现IEnumerable<T> 接口，通过GetEnumerator() 方法获取枚举器：

 

class Sector<T> : IEnumerable<T>
        where T : IComparable<T>
    {
        T[] student;

        public Sector(T[] t)
        {
            student = t;
        }

        public IEnumerator<T> GetEnumerator()
        {
            return new SectorEnumator<T>(student);
            //throw new NotImplementedException();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            //throw new NotImplementedException();
            return null;
        }
    }

这样，在我们以后创建一个Sector 对象以后，就可以直接用foreach 对Sector对象中的Student 对象进行枚举:

 Sector<Student> sector = new Sector<Student>(student);
            foreach (Student t in sector)
            {
                Console.WriteLine(t.Age);
            }

Mr_yinwei
关注
C# 枚举器 手动实现枚举器 可枚举集合 枚举器操作 迭代器
Work Hard, Play Harder!
09-24 3631
在C#语言中提供 foreach 查询操作，foreach 大大的简化了要编写的代码，但是foreach 只能用来遍历一个可枚举的集合（enumable），可枚举的集合就是实现了System.Collections.IEnumerable接口的一个集合。   但是foreac
C#枚举集合、IEnumerable接口、IEnumerator接口、手动实现枚举器、使用迭代器来定义枚举器
qq_44800780的博客
10-25 568
枚举聚合中的元素 之前我们写过这样的代码： foreach极大简化了需要编写的代码，但是foreach只能在特定情况下使用-只能遍历可枚举集合. 什么是可枚举集合？就是实现了System.Collections.IEnumerable接口的集合 可以看到IEnumerable接口包含了一个名为GetEnumerator的方法: GetEnumerator返回IEnumerator 也就是返回了...
C# 中的枚举器
汤母嗑螺蛳
01-18 518
C# 中的枚举器术语表Iterator：枚举器如果你正在创建一个表现和行为都类似于集合的类，允许类的用户使用foreach语句对集合中的成员进行枚举将会是很方便的。这在C# 2.0中比 C# 1.1更容易实现一些。作为演示，我们先在 C# 1.1中为一个简单的集合添加枚举，然后我们修改这个范例，使用新的C#2.0 枚举构建方法。我们将以创建一个简单化的List Box作为开始，它将
C# 枚举器
weixin_30846599的博客
09-06 258
1：枚举器和可枚举类型 我们知道使用foreach可以遍历数组中的元素。那么为什么数组可以被foreach语句处理呢，下面我们就进行讨论一下这个问题。 2：使用foreach语句 我们知道当我们使用foreach语句的时候，这个语句为我们依次取出了数组中的每一个元素。 例如下面的代码： 1 int[] arr = { 1, 2, 3, 4, 5, 6 }; ...
C#图解教程 第十八章 枚举器和迭代器
weixin_38166793的博客
03-14 423
枚举器和迭代器 枚举器和可枚举类型 foreach语句 IEnumerator接口 使用IEnumerable和IEnumerator的示例 泛型枚举接口迭代器 迭代器块使用迭代器来创建枚举器使用迭代器来创建可枚举类型 常见迭代器模式产生多个可枚举类型将迭代器作为属性迭代器实质 枚举器和迭代器 枚举器和可枚举类型 第12章中，我们看到可以用foreach语句遍历数...
深入了解c# 迭代器和列举器
12-17
在实际编程中，通常不需要手动实现迭代器，因为许多内置的集合类（如数组、列表、集合）已经实现了`IEnumerable<T>`接口。例如，`foreach`循环的背后就是通过调用`GetEnumerator()`来遍历元素。在给定的代码示例中，...
C#中可枚举类型详解
08-29
C# 中的可枚举类型是指实现了 IEnumerable 和 IEnumerator 接口的类型，这些类型可以被 foreach 循环迭代。可枚举类型的主要特点是可以枚举一个集合中的数据项，例如数组、列表、哈希表等。 IEnumerable 接口是可...
C#使用yield关键字构建迭代器详解
08-29
C#中的yield关键字是用于构建迭代器的，它可以让开发者更方便地实现IEnumerable接口，从而支持foreach枚举。yield关键字的出现使得迭代器的编写变得更加简单和灵活。 在C#中，使用yield关键字可以让方法返回...
C#中 枚举器的概念
qq_74158527的博客
07-28 293
常见的集合类型（例如数组、列表、集合等）都实现了枚举器接口，这样我们就可以使用类似循环结构（例如`for`、`while`循环）来逐个访问集合中的元素，而无需知道底层数据结构的细节。枚举器为集合提供了一种标准的方式来遍历元素，并且在遍历时可以执行一些特定的操作，比如访问元素、删除元素（在某些情况下）或者执行其他自定义的逻辑。在不同的编程语言和框架中，枚举器的用法可能会有一些差异，但它们的基本目标都是为了提供一种统一的、可重复使用的方法来遍历集合中的元素。
C# 入门（14） 枚举器（enumerator）和迭代器（iterator）
l773575310的博客
05-04 4711
C#的枚举器和迭代器
C#枚举器和迭代器
Javaigood的博客
10-17 1632
C#枚举器和迭代器
C# IEnumerator枚举器
HobbitX的博客
04-25 6820
1、对象只要一个类型实现了IEnumerable接口就能遍历 2、IEnumerator是枚举器，一个接口类，实现MoveNext->Current->Reset 3、yield关键字是一个迭代器，相当于实现了IEnumerator枚举器 4、IEnumerable是可枚举类型，IEnumerator是枚举器 public class IEnumerableShow { public void Show() { int[] array = { 1, 2,
C#极简方式实现枚举器的例子
u012846041的专栏
05-25 207
yield 关键字向编译器指示它所在的方法是迭代器块 //=================直接将Publishers定义枚举接口类型，在属性在遍历与该属性对应的私有变量内容，通过yield关键字返回即可=================== //=============省略了原有定义为枚举对象，再定义内部枚举器的繁琐过程=================================
C#语言进阶(四) 枚举器和迭代器
最新发布
记录知识点的博客
05-08 996
C#语言进阶(四) 枚举器和迭代器
C#学习笔记（十三）枚举器和迭代器
khq溪风的博客
03-20 676
第十八章 IEnumerator接口：实现了IEnumerator接口的枚举器有三个函数成员：Current、MoveNext和Reset；Current返回当前位置的属性，它是只读属性；MoveNext前进位置到下一项，如果新的位置是有效的（没有到达序列尾部），返回true，否则返回false，并且在调用Current之前，先调用MoveNext（因为枚举器的原始位置在序列的第一项之前）；Re...
C#自定义枚举类的实现
suneboy的专栏
09-16 7891
一个最简单的枚举类 public enum sex { male=0, female=1 } 然而使用或绑定时需要中文，解决办法有以下几种： 1. public enum sex { 男人=0, 女人=1 } 2.（参考他人） publ
C#-14 枚举器和迭代器
chinaherolts2008的博客
05-28 391
一 枚举器和可枚举类型 当我们为数组使用foreach语句时，这个语句为我们依次取出了数组中的每一个元素。 var arrInt = new int[] { 11, 12, 13, 14 }; foreach (var item in arrInt) { Console.WriteLine(item); } 原因是数组实现了IEnumerable接口，接口提供了一个GetEnumerator方法可以获取一个实现了IEnumerator接口的枚举器对象。 枚举器可以依次返回请求的数组中的..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值