C#集合-列举（Enumeration）

最新推荐文章于 2024-08-02 19:07:49 发布

转载最新推荐文章于 2024-08-02 19:07:49 发布 · 195 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/yang_sy/p/3596457.html

文章标签：

#数据结构与算法 #c# #数据库

本文深入探讨了C#中的IEnumerable与IEnumerator接口，解释了它们在集合遍历中的作用，包括非泛型与泛型版本的区别，以及如何通过yield return语句实现集合遍历。同时，文章还对比了IEnumerator与Iterator的概念，帮助读者理解两者之间的差异。

在计算机这个范畴内存在许多种类的集合，从简单的数据结构比如数组、链表，到复杂的数据结构比如红黑树，哈希表。尽管这些数据结构的内部实现和外部特征大相径庭，但是遍历集合的内容确是一个共同的需求。.NET Framework通过IEnumerable和IEnumerator接口实现遍历集合功能。

Non-Generic	Generic	备注
IEnumerator	IEnumerator<T>
IEnumerable	IEnumerable<T>	仅可遍历
ICollection	ICollection<T>	遍历，可统计集合元素
IDictionary IList	IDictionary<TKey,TValue> IList<T>	拥有更过的功能

IEnumerable与IEnumerator

IEnumerator接口定义了遍历协议--在这个协议中，集合中的元素使用向前的方式进行遍历。它的声明如下：

public interface IEnumerator
{   
    bool MoveNext();
   
    Object Current { get; }

    void Reset();
}

MoveNext将当前元素或指针移动到下一个位置，如果下一个位置没有元素那么返回false。Current返回在当前值位置的元素。在获取集合的第一个元素之前，必须调用MoveNext方法--这对于空集合同样适用。Reset方法，这移动到初始位置，从而允许集合可以再次遍历。Reset更过多是为COM互操作而设计：应该尽量直接避免调用此方法，因为它并没有得到普遍的支持（直接调用此方法是不必要的，因为创建一个新的列举实例更容易）。

集合一般都不实现列举器，相反，它们通过IEnurable接口提供列举器

public interface IEnumerable
{   
    IEnumerator GetEnumerator();
}

通过定义一个单一返回列举器的方法，IEnumerable接口提供了更多的灵活性，从而各个实现类的遍历集合的逻辑可以各部相同。这也就意味着每个集合的使用者都可以创建自己的方法遍历集合而不会相互影响。IEnumerable可以被视作IEnumeratorProvider，它是所有集合类都必须实现的一个接口。

下面的代码演示了如何使用IEnumerable和IEnumerator：

string s = "Hello";

// IEnumerator
IEnumerator rator = s.GetEnumerator();
while (rator.MoveNext())
    Console.Write(rator.Current + ".");

Console.WriteLine();

// IEnumerable
foreach (char c in s)
    Console.Write(c + ".");

一般地，很少调用GetEnumerator方法得到IEnumerator接口，这是由于C#提供了foreach语法(foreach语法编译后，会自动调用GetEnumerator从而遍历集合)，这使得代码变得更简洁。

IEnumerable<T>与IEnumerator<T>

IEnumerator和IEnumerable对应的Generic接口定义如下：

public interface IEnumerator<out T> : IDisposable, IEnumerator
{    
       new T Current {
        get; 
    }
}
public interface IEnumerable<out T> : IEnumerable
{ 
    new IEnumerator<T> GetEnumerator();
}

Generic的Current和GetEnumerator，增加了接口IEnumerable<T>与IEnumerator<T>的类型安全性，避免了对值类型进行装箱操作，对于集合的使用者更加便利。请注意，数字类型默认实现了IEnumerable<T>接口。

正是由于实现了类型安全的接口，方法Test2(arr)在编译时就会报错：

static void Main(string[] args)
{
    char[] arr = new char[] { '1', '2', '3' };
    Test1(arr);  // ok
    Test2(arr); // complie-error: cannot convert from char[] to IEnumerable[]

    Console.ReadLine();
}

static void Test1(IEnumerable numbers)
{
    foreach (object i in numbers)
        Console.Write(i + ",");
}

static void Test2(IEnumerable<int> numbers)
{
    foreach (object i in numbers)
        Console.Write(i + ",");
}

请注意，Array默认实现了IEnumerable<T>接口，那么它同时必然实现了IEnumerable接口。虽然char[]不能转换成IEnumrable<int>，但是却可以转换成IEnumeable,所以Test1可以通过编译，而Test2不能通过编译（类型转化失败错误）

对于集合类，对外暴露IEnumerable<T>是标准做法；并需要显示地实现IEnumerable接口，从而隐藏非Generic的IEnumerable。此时，你再调用GetEnumerator，将得到IEnumerator<T>。但有时候，为了兼容非Generic的集合，我们可以不遵守这个规则。最好的例子就是数组集合，数组必须返回非generic的IEnumerator以避免与早期的代码冲突。在这种情况下，为了获取IEnumerator<T>,就必须先把数组显示地转化为Generic接口，然后再获取：

char[] arr = new char[] { '1', '2', '3' };
var rator = ((IEnumerable<char>)arr).GetEnumerator();

幸运的是，你很少需要编写这样的代码，这就要归功于foreach语句。

IEnumerable<T>和IDisposable

IEnumerator<T>继承了IDisposable。这就允许列举器可以拥有资源的引用比如数据库连接，从而确保在遍历完成后释放这些资源。foreach会语句会识别这个特性，比如，下面的foreach语句

IList<char> chars =new List<char>(){'a', 'b', 'c'};
 foreach (char c in chars)
     Console.Write(c);

编译后的代码为：

.method private hidebysig static void  Main(string[] args) cil managed
{
 ......
  IL_0026:  callvirt   instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> class [mscorlib]System.Collections.Generic.IEnumerable`1<char>::GetEnumerator()
  IL_002b:  stloc.3
  .try
  {
   .......
System.Collections.Generic.IEnumerator`1<char>::get_Current()
   ......
    IL_0036:  call       void [mscorlib]System.Console::Write(char)
    ......
    IL_003d:  callvirt   instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
  ......
  }  // end .try
  finally
  {
    ......
    IL_0055:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
   ......
  }  // end handler
  ......
} // end of method Program::Main

因此，如果实现了IEnumable<T>接口，执行foreach时，会转化成调用GetEnumerator<T>, 在遍历完成之后，释放IEnumerator<T>。

实现列举接口

当满足下面的一个或多个条件时，需要实现IEnumerable或IEnumerable<T>

为了支持foreach语句
为了实现除了标准集合之外的集合都是可互操作的
为了满足一个复杂集合接口
为了支持集合初始化

而实现IEnumerable/IEnumerable<T>，你必须提供一个列举器，你可以通过下面三种方式实现

如果类包含了另外集合，那么需要返回所包含集合的列举器
在迭遍历内部使用yield return
实例化IEnumerator/IEnumerator<T>的实现

1）实例IEnumerator/IEnumerator<T>

返回另外一个集合的列举器就是调用内部集合的GetEnumerator。但是，这只发生在简单的场景中，在这样的场景中，内部集合中的元素已经满足需要。另外一种更为灵活的方式是通过yield return语句生成一个迭代器。迭代器(iteraotr)是C#语言特性，该特性用于辅助生产集合，同样地foreach可与用于iterator以遍历集合。一个迭代器自动处理IEnumerable和IEnumerator的实现。下面是一个简单的例子

internal class MyCollection : IEnumerable
{
    int[] data ={ 1, 2, 3 };

    public IEnumerator GetEnumerator()
    {
        foreach (int i in data)
            yield return i;
    }
}

请注意，GetEnumerator根本就没有返回一个列举器。依赖于解析yield return后的语句，编译器编写了一个隐藏的内嵌列举器类，然后重构 GetEnumerator实现实例化，最后返回该类。迭代不仅功能强大而且简单。

通过IL代码，我们可以看到确实生产了一个内嵌的列举器类

我们在上面代码的基础上，对MyCollecton做些许修改，使其不仅仅实现IEnumerable，还实现IEnumerable<T>

internal class MyCollection : IEnumerable<int>
{
    int[] data ={ 1, 2, 3 };        

    public IEnumerator<int> GetEnumerator()
    {
        foreach (int i in data)
            yield return i;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

因为IEnumerable<T>继承了IEnumerable，因此我们必须实现generic的GetEnumerator和非generic的GetEnumerator。按照标准的做法，我们已经实现了Generic的GetEnumerator。因此对于非Generic的GetEnumerator，我们直接调用Generic的GetEnumerator即可，这是因为IEnumerable<T>继承了IEnumerbale。

对应的IL代码如下：（请注意编译器实现的IEnumerator<Int32>接口，而不再是IEnumerator<Object>接口）

2）在使用yield return返回IEnumerable<T>

我们创建的类MyCollection可以做为复杂集合类的基本实现。但是，如果你不需要实现IEnumerable<T>，那么应可以通过yield return语句实现一个IEnumerable<T>，而不是编写MyCollection这样的类。也就是说你可以把迭代逻辑迁移到一个返回IEnumerable<T>的方法中，然后让编译器来为你完成剩余的事情。

class Program
{
    static void Main(string[] args)
    {

        foreach(int i in GetSomeIntegers())
            Console.WriteLine(i);

        Console.ReadLine();
    }

    static IEnumerable<int> GetSomeIntegers()
    {
        int[] data = { 1, 2, 3 }; 
        foreach (int i in data)
            yield return i;
    }       
}

与之对应的IL代码

从IL代码中，我们可以看到，编译器同样生产了一个内部的类，该类实现了IEnumerator<Int32>接口。

3）如果类包含了另外集合，那么需要返回所包含集合的列举器

最后一种实现方式将就是编写一个类直接实现IEnumerator接口。其实这也就是编译器之前做的事情。在实际中，你不需要这么做。

首先我们来实现非Generic的IEnumerator

internal class MyCollection : IEnumerable
{
    int[] data ={ 1, 2, 3 };        

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

    private class Enumerator : IEnumerator
    {
        MyCollection collection;
        int index;

        public Enumerator(MyCollection collection)
        {
            this.collection = collection;
            index = -1;
        }

        public object Current
        {
            get { return collection.data[index]; }
        }

        public bool MoveNext()
        {
            if (index < collection.data.Length-1)
            {
                index++;
                return true;
            }

            return false;
        }

        public void Reset()
        {
            index = -1;
        }
    }
}

然后，我们在上述代码的基础上，实现Generic的IEnumerator

internal class MyCollection : IEnumerable<Int32>
{
    int[] data = { 1, 2, 3 };

    // implement IEnumerable<T>
    public IEnumerator<Int32> GetEnumerator()
    {
        return new Enumerator(this);
    }
    // implement IEnumerable
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    private class Enumerator : IEnumerator<Int32>
    {
        MyCollection collection;
        int index;

        public Enumerator(MyCollection collection)
            {
                this.collection = collection;
                index = -1;
            }

        #region implement IEnumerator<T>
            public int Current
            {
                get { return collection.data[index]; }
            }

            public void Dispose()
            {
            }            

            public bool MoveNext()
            {
                if (index < collection.data.Length - 1)
                {
                    index++;
                    return true;
                }

                return false;
            }

            public void Reset()
            {
                index = -1;
            }
            #endregion

        // implement IEnumerator
        object IEnumerator.Current
        {
            get { return Current; }
        }
    }
}

Generic版本的IEnumerator比非Generic的IEnumberator效率高一些，因为不需要把int转化成object，从而减少了装箱的开销。我们多看一眼此时对应的IL代码：

显然地，我们可以看到我们手动创建Enumerator与编译器生成的Enumerator是一样的

此外，当我们使用第二种方式的时候，如果我们有多个IEnumerable<T>的方法，那么编译器会产生多个实现了IEnumerator<T>的类

class Program
{
    static void Main(string[] args)
    {

        foreach (int i in GetSomeIntegers())
            Console.WriteLine(i);

        foreach (int i in GetSomeOdds())
            Console.WriteLine(i);

        Console.ReadLine();
    }

    static IEnumerable<Int32> GetSomeIntegers()
    {
        int[] collection = { 1, 2, 3, 4, 5 };
        foreach (int i in collection)
            yield return i;
    }

    static IEnumerable<Int32> GetSomeOdds()
    {
        int[] collection = { 1, 2, 3, 4, 5 };
        foreach (int i in collection)
            if(i%2==1)
                yield return i;
    }       
   
}

对应的IL代码可以看到有两个内部IEnumerator<T>类

而下面的代码只会产生一个IEnumerator<T>类

class Program
{
    static void Main(string[] args)
    {

        foreach (int i in GetSomeIntegers())
            Console.WriteLine(i);

        foreach (int i in GetSomeOdds())
            Console.WriteLine(i);

        Console.ReadLine();
    }

    static IEnumerable<Int32> GetSomeIntegers()
    {
        return GetDetails();
    }

    static IEnumerable<Int32> GetSomeOdds()
    {
        return GetDetails(true);
    }

    private static IEnumerable<Int32> GetDetails(bool isOdd = false)
    {
        int[] collection = { 1, 2, 3, 4, 5 };
        int index = 0;

        foreach (int i in collection)
        {
            if (isOdd && i % 2 == 1)
                yield return i;
            if (!isOdd)
                yield return collection[index];
            
            index++;
        }
    }   
}

同样地，下面的代码也只会产生一个IEnumerator<T>类

....
static IEnumerable<Int32> GetSomeIntegers()
{
    foreach (int i in GetDetails())
        yield return i;
}

static IEnumerable<Int32> GetSomeOdds()
{
    foreach (int i in GetDetails(true))
        yield return i;
}
....

由此，我们可以发现，在实现IEnumerable时，特别是有多个实现时，需要注意尽量减少编译器生成IEnumerator的类的个数。我猜测在内部，编译器应该是根据真正不同的yield return对于的iterator来确定IEnumerator类的个数。在我的示例代码中，产出两个IEnumerator类时，GetSomeIntegers和GetSomeOdds的yield return的iterator是不同的；而在产生一个IEnumerator类时，它们都指向GetDetails的yield return对应的iterator。

最后，我们再来看看IEnumerator与Iterator

在网上，并没有关于两者的明确区分，或许是我把两个不该混淆的概念混淆了。下面是我自己的看法，如果不正确，欢迎指正：

1）实现IEnumerator用于实现IEnumerable，与GetEnumerator方法关联在一起，从而可以使用foreach；而且一旦一个类中确定了遍历（MoveNext）的方式之后，那么就只有这一种方式去遍历集合了。.NET Framework中大多数集合的IEnumerator都默认向前只读的方式遍历集合。

2）Iterator用于遍历集合，可以有多个实现方式，唯一的要求是返回IEnumerator<T>，从某种意义上说，Iterator就是IEnumerator。两者的区别是，前者一旦确定，就只能使用这个方式遍历集合然后返回一个IEnumerator；而后者可以在多个方法中以多种方式遍历集合然后返回不同的IEnumerator。（我认为，两者的差别与IComparable和IComparer的差别类似）。

转载于:https://www.cnblogs.com/yang_sy/p/3596457.html