C#接口学习之IEnumerable接口及其泛型版本（二）

最新推荐文章于 2025-04-25 09:46:11 发布

原创最新推荐文章于 2025-04-25 09:46:11 发布 · 1.7k 阅读

7 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

本文继续深入探讨C#的泛型接口IEnumerable<T>，解释其引入背景和解决的问题，以及如何避免装箱拆箱操作带来的性能损耗。通过实例展示了如何使用IEnumerable<T>实现可迭代集合，并给出了代码执行的测试数据。

通过上篇文章（C#接口学习之IEnumerable接口及其泛型版本（一）），我相信对于一些刚开始接触C#这门语言的小伙伴来说，多少还是能有点收获的。本文开始将继续介绍C#泛型接口IEnumerable<T>。

我们知道，微软在.NET 2.0中引入了泛型的概念。泛型的出现使得类型可以被当作参数一样使用，从而无需再为不同的类型创建不同的代码实现。关于泛型的优点，我在这里不做过多介绍，但通过一个例子我会告诉你使用泛型接口IEnumerable<T>的必要性。让我们先回看一下IEnumerator的接口声明：

//代码段
public interface IEnumerator
{    
　　bool MoveNext(); 
　　object Current{get;}    
　　void Reset();
}

在C#1时代，我们通常通过实现IEnumerator接口的方式来实现迭代器。但是，这种实现方式却存在一个问题，那就是Current属性的数据类型是object。这就意味着当你遍历一个由值类型构成的集合时，将会执行装箱与拆箱的操作，而遍历引用类型构成的集合则又需要进行不必要的类型转换。我们应当避免这样的性能损耗。好在在C#2中，微软为了解决这一问题，贴心的为我们加入了IEnumerable的泛型版本IEnumerable<T>：

public interface IEnumerable<out T> : IEnumerable
{
    IEnumerator<T> GetEnumerator();
}

public interface IEnumerator<out T> : IDisposable, IEnumerator
{
    T Current { get; }
}

有一个说法是泛型接口都应该继承自它们对应的非泛型接口。事实上，在微软.NET Framework中只有IEnumerable<T>是这样的。但是这也在开发者引起一些争议，内容是IEnumerable<T>是否应该继承IEnumerable。原因是当你试图用IEnumerable<T>接口为你的某个自定义类型实现迭代时，由于继承的关系，你不得不需要实现两个不同的方法：

public IEnumerator<T> GetEnumerator()
{
    ……
}

IEnumerator GetEnumerator()
{
    return GetEnumerator();
}

这一问题也同时出现在IEnumerator<T>中：

public T Current
{
    ……
}

object Current
{
    get { return Current; }
}

虽然很多开发者认为IEnumerable<T>不应该继承IEnumerable，但无论如何，都不会对我们的使用造成任何影响。正式由于IEnumerable<T>实现了IEnumerable接口，使得我们能够在接受IEnumerable类型参数的地方，同样可以使用IEnumerable<T>。

如何使用泛型接口实现一个可迭代的集合？

我们依然使用上一篇文章中的例子，进行一个简单的修改：

public class Students<T> : IEnumerable<T>
{
    private T[] arrStudent;

    public Students()
    {

    }

    public Students(T[] collection)
    {
        arrStudent = collection;
    }

    public T this[int index]
    {
        get { return arrStudent[index]; }
    }

    public int Count
    {
        get { return arrStudent.Length; }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new StudentIterator<T>(this);
    }

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

public class StudentIterator<T> : IEnumerator<T>
{
    private Students<T> arrStudents;
    private int idx;

    internal StudentIterator(Students<T> collection)
    {
        this.arrStudents = collection;
        idx = -1;
    }
    public T Current
    {
        get { return arrStudents[idx]; }
    }

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

    public bool MoveNext()
    {
        idx++;
        return idx < arrStudents.Count;
    }

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

    public void Dispose()
    {
            
    }
}

最后，按照惯例来检查代码执行情况，输入测试数据：

GenericIteratorInCS1.Students<Student> arrStudent1 = new GenericIteratorInCS1.Students<Student>(
    new Student[] { 
        new Student() { Name = "张三", Age = 23 },
        new Student() { Name = "李四", Age = 24 },
        new Student() { Name = "王五", Age = 45 },
        new Student() { Name = "DDD", Age = 21 },
        new Student() { Name = "BBB", Age = 14 },
        new Student() { Name = "CCC", Age = 3 },
        new Student() { Name = "AAA", Age = 22 },
        new Student() { Name = "BBB", Age = 55 },
        new Student() { Name = "CCC", Age = 43 },
    });

foreach(Student obj in arrStudent1)
{
    Console.WriteLine("姓名：" + obj.Name + ",年龄：" + obj.Age);
}

运行结果：