c#迭代

最新推荐文章于 2024-02-26 09:16:57 发布

MarioFei

最新推荐文章于 2024-02-26 09:16:57 发布

阅读量1.2k

点赞数 1

摘要：迭代器是C#2.0中添加的功能，它能够使我们在类或结构中支持 foreach迭代，而不必实现整个IEnumerable/IEnumerable接口。今天我们就一块看一下什么是c#中的迭代器吧。

主要内容：

1.foreach的运行机制

2.传统集合的遍历

3.使用迭代器

一、foreach的运行机制

我们在程序中经常会用到foreach，如果你把它理解成是for的一种简写形式的话那就太大材小用了，事实上foreach中包含了丰富的内容。我们知道要使用foreach遍历集合就必须实现 IEnumerable接口，而要实现IEnumerable接口就要实现IEnumerator接口。关于如何实现这两个接口我们在第二部分会看到，在谈foreach的运行机制之前请允许我使用msdn中的Person类（我们下面的几部分中我们还会用到相关的People和PeopleEnum类）：

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

namespace IteratorDemo
{
    class Person
    {
        public Person(string fName, string lName)
        {
            this.firstName = fName;
            this.lastName = lName;
        }

        public string firstName;
        public string lastName;
    }
}

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

namespace IteratorDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Person[] persons = new Person[] { 
                new Person("Kenshin","Cui"),
                new Person("Miaoer","Sun"),
                new Person("Jinjuan","Shen"),
                new Person("Yanxin","Nie")
            };
            foreach (Person p in persons)
            {
                Console.WriteLine(p.firstName + " " + p.lastName);
            }
            Console.Read();
        }

    }
}

具体的运行结果也没有什么可说的，可是为什么会有这样的结果呢？原因可以分两层来解释：第一就是我们的Persons是使用[]符号声明，这是一个 Array类的记号。而 Array类实现了IEnumerable接口中GetEnumerator()方法，因此它可以使用foreach进行迭代；第二，之所以实现IEnumerable接口的GetEnumerator()方法就能够迭代是因为foreach将上面的代码解析成如下的形式：

IEnumerator enuerator = persons.GetEnumerator();
            while (enuerator.MoveNext())
            {
                Person p = enuerator.Current as Person;
                Console.WriteLine(p.firstName + " " + p.lastName);
            }
            Console.Read();

我们知道 GetEnumerator()方法返回一个IEnumerator类型的接口，在IEnumerator接口中有一个Current属性来返回当前元素，而其M oveNext()方法又可以移动到集合的下一个元素（有则返回true，无则返回false），如此反复就形成了对整个集合的迭代（具体原理可以参见上面链接的内容）。

总结下：一个类型想要foreach 需要实现的是 IEnumerable接口实现GetEnumerator()方法

这个方法返回的是实现IEnumerator接口的类，类中成员Current返回当前元素，MoveNext用于定位

十分原始的实现方式

using System;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace fanxing
{
    public class iterator
    {
        static void Main(string []args)
        {
            persons collection = new persons();
            foreach(person p in collection)
            {
                Console.WriteLine(p.Name);
            }
        }
    }
    class person
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public person(string name)
        {
            this.name = name;
        }
    }
    class persons:IEnumerable
    {
        private person[] array;

        public persons()
        {
            array = new person[]
            {
                new person("11"),
                new person("22"),
                new person("33")
            };
        }

        public int getCount()
        {
            return array.Length;
        }

        public person getPerson(int index)
        {
            return array[index];
        }

        public IEnumerator GetEnumerator()
        {
            return new personIterator(this);
        }

    }

    class personIterator:IEnumerator
    {
        private persons persons;
        private int index;
        private person current;

        public object Current
        {
            get
            {
                return this.current;
            }
        }
        
        internal personIterator(persons persons)
        {
            this.persons = persons;
            index = 0;
        }

        public bool MoveNext()
        {
            if(index+1>persons.getCount())
            {
                return false;
            }
            else
            {
                this.current = persons.getPerson(index);
                index++;
                return true;
            }
        }

        public void Reset()
        {
            index = 0;
        }
    }

}<span style="color:#ff0000;">
</span>

三、使用迭代器

截止到现在我们可以看到如果让一个类或结构支持foreach就必须实现整个IEnumerable接口，这显然过于麻烦，毕竟我们不想在这方面花费太多的时间，那么此时我们就来使用迭代器吧。创建迭代器的最常用的方法就是对IEnumerable接口实现GetEnumerator()方法，例如将上面的People类可以写成这样：

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

namespace IteratorDemo
{
    class People:IEnumerable
    {
        private Person[] _people;
        public People(Person[] pArray)
        {
            _people = new Person[pArray.Length];

            for (int i = 0; i < pArray.Length; i++)
            {
                _people[i] = pArray[i];
            }
        }

        public IEnumerator GetEnumerator()
        {
            for (int i = 0; i < _people.Length; ++i)
            {
                yield return _people[i];//只需要一句话就可以了
            }
        }
    }
}

从上面我们可以看到我们完全省略了创建PeopleEnum的过程（事实上我们还可以更简单，下面我们就可以看到，这里主要为了和上面的例子做个对比），当然这一切都归功于迭代器的功劳。迭代器使用yield return语句返回每个元素，yield break终止迭代（其返回类型必须为IEnumerable/IEnumerable、IEnumerator/Ienumerator类型）。yield关键字用于指定返回值，到达yield break时会保存当前位置，直到下次调用迭代器时将从此位置从新开始执行。当编译器见到迭代器时，会自动生成IEnumerable/IEnumerable接口的Current、MoveNext和Dispose方法。

yeild的作用是简化枚举器，也就是IEnumerator<T>或IEnumerable<T>的实现。“人肉”反编译的关键在于发现编译器的规律，因此我们先来观察编译器的处理结果。值得注意的是，我们这里所谈的“分析”，都采用的是微软目前的C# 3.0编译器。从理论上来说，这些结果或是规律，都有可能无法运用在Mono和微软之前或今后的C#编译器上。首先我们准备一段使用yield的代码：

static IEnumerator<int> GetSimpleEnumerator()
{
    Console.WriteLine("Creating Enumerator");

    yield return 0;
    yield return 1;
    yield return 2;

    Console.WriteLine("Enumerator Created");
}

为了简化问题，我们在这里采用IEnumerator<T>。自动生成的IEnumerable<T>和IEnumerator<T>区别不大，您可以自己观察一下，有机会我会单独讨论和分析其中的区别。经过编译之后再使用.NET Reflector进行反编译，得到的结果是：

private static IEnumerator<int> GetSimpleEnumerator()
{
    return new <GetSimpleEnumerator>d__0(0);
}

[CompilerGenerated]
private sealed class <GetSimpleEnumerator>d__0 : IEnumerator<int>, ...
{
    // Fields
    private int <>1__state;
    private int <>2__current;

    // Methods
    [DebuggerHidden]
    public <GetSimpleEnumerator>d__0(int <>1__state)
    {
        this.<>1__state = <>1__state;
    }

    private bool MoveNext()
    {
        switch (this.<>1__state)
        {
            case 0:
                this.<>1__state = -1;
                Console.WriteLine("Creating Enumerator");
                this.<>2__current = 0;
                this.<>1__state = 1;
                return true;

            case 1:
                this.<>1__state = -1;
                this.<>2__current = 1;
                this.<>1__state = 2;
                return true;

            case 2:
                this.<>1__state = -1;
                this.<>2__current = 2;
                this.<>1__state = 3;
                return true;

            case 3:
                this.<>1__state = -1;
                Console.WriteLine("Enumerator Created");
                break;
        }

        return false;
    }

    ...
}

以上便是编译器生成的逻辑，它将yield关键字这个语法糖转化为普通的.NET结构（再次强调，这只是微软目前的C# 3.0编译器所产生的结果）。从中我们可以得出一些结论：

原本GetSimpleEnumerator方法中包含yield的逻辑不复存在，取而代之的是一个由编译器自动生成的IEnumerator类的实例。
原本GetSimpleEnumerator方法中包含yield的逻辑，被编译器自动转化为对应IEnumerator类中的MoveNext方法的逻辑。
编译器将包含yield逻辑转化为一个状态机，并使用自动生成的state字段保存当前状态。
每次调用MoveNext方法时，都通过switch语句判断state的值，直接进入特定的逻辑片断，并指定下一个状态。

因为从yield关键字的作用便是“中断”一个方法的逻辑，使它在下次执行MoveNext方法的时候继续执行。这就意味着自动生成的MoveNext代码必须通过某一个手段来保留上次调用结束之后的“状态”，并根据这个状态决定下次调用的“入口”——这是个典型的状态机的“思路”。由此看来，编译器如此实现，其“设计”意图也是比较直观的，相信您理解起来也不会有太大问题。

MarioFei

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
c#迭代

摘要：迭代器是C#2.0中添加的功能，它能够使我们在类或结构中支持foreach迭代，而不必实现整个IEnumerable/IEnumerable接口。今天我们就一块看一下什么是c#中的迭代器吧。主要内容：1.foreach的运行机制2.传统集合的遍历3.使用迭代器一、foreach的运行机制我们在程序中经常会用到foreach，如果你把它理解成是f
复制链接

扫一扫