C#学习：集合、迭代、泛型（1）

一、System.Collections名称空间下几个接口表征着集合的功能：

1、IEnumerable：表征着迭代功能

public interface IEnumerable
{

    IEnumerator GetEnumerator();
}

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

注意，IEnumerator也属于System.Collections空间。

2、其它诸如：ICollection IList IDictionary 都表征着相应的集合功能。它们的代码如下：

public interface ICollection : IEnumerable
{
    void CopyTo(Array array, int index);

    int Count { [__DynamicallyInvokable] get; }
}

public interface IList : ICollection, IEnumerable
{
    // Methods
    int Add(object value);
    void Clear();
    bool Contains(object value);
    int IndexOf(object value);
    void Insert(int index, object value);
    void Remove(object value);
    void RemoveAt(int index);

}

public interface IDictionary : ICollection, IEnumerable
{
    // Methods
    [__DynamicallyInvokable]
    void Add(object key, object value);
    [__DynamicallyInvokable]
    void Clear();
    [__DynamicallyInvokable]
    bool Contains(object key);
    [__DynamicallyInvokable]
    IDictionaryEnumerator GetEnumerator();
    [__DynamicallyInvokable]
    void Remove(object key);

    // Properties
    bool IsFixedSize { [__DynamicallyInvokable] get; }
    bool IsReadOnly { [__DynamicallyInvokable] get; }
    object this[object key] { [__DynamicallyInvokable] get; [__DynamicallyInvokable] set; }
    ICollection Keys { [__DynamicallyInvokable] get; }
    ICollection Values { [__DynamicallyInvokable] get; }
}

上面说的都是接口，它们内部都是些方法声明而已。具体的类，比如System.Array和System.Collections.ArrayList里面才有具体的方法实现。

System.Collections.ArrayList是System.Object对象的集合。

二、创建自己的集合：

一种方式是我们手动实现集合的所有方法，另一种方式是我们继承System.Collections.CollectionBase类。CollectionBase类已经实现了IEnumerable和ICollection、IList接口。

1、在继续之前，我们先来看看CollectionBase是怎么实现的：

[Serializable, ComVisible(true), __DynamicallyInvokable]
public abstract class CollectionBase : IList, ICollection, IEnumerable
{
    // Fields
    private ArrayList list;

    // Methods
    protected CollectionBase();
    protected CollectionBase(int capacity);
    public void Clear();
    public IEnumerator GetEnumerator();
    protected virtual void OnClear();
    protected virtual void OnClearComplete();
    protected virtual void OnInsert(int index, object value);
    protected virtual void OnInsertComplete(int index, object value);
    protected virtual void OnRemove(int index, object value);
    protected virtual void OnRemoveComplete(int index, object value);
    protected virtual void OnSet(int index, object oldValue, object newValue);
    protected virtual void OnSetComplete(int index, object oldValue, object newValue);
    protected virtual void OnValidate(object value);
    public void RemoveAt(int index);
    void ICollection.CopyTo(Array array, int index);
    int IList.Add(object value);
    bool IList.Contains(object value);
    int IList.IndexOf(object value);
    void IList.Insert(int index, object value);
    void IList.Remove(object value);

    // Properties

    public int Capacity { get; set; }
    public int Count { [__DynamicallyInvokable] get; }
    protected ArrayList InnerList { get; }
    protected IList List { get; }
    bool ICollection.IsSynchronized { get; }
    object ICollection.SyncRoot { get; }
    bool IList.IsFixedSize { get; }
    bool IList.IsReadOnly { get; }
    object IList.this[int index] { get; set; }
}

可知，CollectionBase是基于ArrayList的，GetEnumerator便是对IEnumerable接口的实现，它返回了一个IEnumerator，那么这个IEnumerator内部到底做了什么使得ICollection可以迭代（通过foreach）呢，显然，CollectionBase没有做这个工作，这个工作是由ArrayList来做的。具体来说是这样：CollectionBase有一个list数据成员，它不是属性（名称用camel命名法，且没有getter/setter），InnerList也是CollectionBase的属性，这个属性的代码以及GetEnumerator的代码如下：

protected ArrayList InnerList
{
    get
    {
        if (this.list == null)
        {
            this.list = new ArrayList();
        }
        return this.list;
    }
}

public IEnumerator GetEnumerator()
{
    return this.InnerList.GetEnumerator();
}

可以看到，确实是基于ArrayList的。
2、那么，我们来看看ArrayList是怎么实现迭代的：

public class ArrayList : IList, ICollection, IEnumerable, ICloneable
{
    // Fields
    private const int _defaultCapacity = ;
    private object[] _items;
    private int _size;

    。。。

   public virtual IEnumerator GetEnumerator()
    {
        return new ArrayListEnumeratorSimple(this);
    }

    。。。

   private sealed class ArrayListEnumeratorSimple : IEnumerator, ICloneable
    {
        // Fields
        private object currentElement;
        private static object dummyObject;
        private int index;
        [NonSerialized]
        private bool isArrayList;
        private ArrayList list;
        private int version;

        // Methods
        static ArrayListEnumeratorSimple();
        internal ArrayListEnumeratorSimple(ArrayList list);
        public object Clone();
        public bool MoveNext();
        public void Reset();

        // Properties
        public object Current { get; }
    }

}

可以看到ArrayList自己也没干活，而是把迭代任务交给了自己的一个内部类ArrayListEnumeratorSimple，其中有一个构造的修饰符是internal，意思是这个方法只能在程序集内部调用。该类有一个list成员，这个成员便是当ArrayList的GetEnumerator方法调用时把this，即ArrayList自己传给了ArrayListEnumeratorSimple的构造，从而ArrayListEnumeratorSimple的list也就得到初始化了。具体实现代码如下：

 private sealed class ArrayListEnumeratorSimple : IEnumerator, ICloneable
{
    // Fields
    private object currentElement;
    private static object dummyObject;
    private int index;
    private bool isArrayList;
    private ArrayList list;
    private int version;

    // Methods
    static ArrayListEnumeratorSimple()
    {
        dummyObject = new object();
    }

    internal ArrayListEnumeratorSimple(ArrayList list)
    {
        this.list = list;
        this.index = -;
        this.version = list._version;
        this.isArrayList = list.GetType() == typeof(ArrayList);
        this.currentElement = dummyObject;
    }

    public object Clone(){/*...*/}
    public bool MoveNext()
    {
        if (this.version != this.list._version)
        {
            throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumFailedVersion"));
        }
        if (this.isArrayList)
        {
            if (this.index < (this.list._size - ))
            {
                this.currentElement = this.list._items[++this.index];
                return true;
            }
            this.currentElement = dummyObject;
            this.index = this.list._size;
            return false;
        }
        if (this.index < (this.list.Count - ))
        {
            this.currentElement = this.list[++this.index];
            return true;
        }
        this.index = this.list.Count;
        this.currentElement = dummyObject;
        return false;
    }

    public void Reset()
    {
        if (this.version != this.list._version)
        {
            throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumFailedVersion"));
        }
        this.currentElement = dummyObject;
        this.index = -;
    }

    public object Current
    {
        get
        {
            object currentElement = this.currentElement;
            if (dummyObject != currentElement)
            {
                return currentElement;
            }
            if (this.index == -)
            {
                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumNotStarted"));
            }
            throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumEnded"));
        }
    }

}

迭代的原理很简单：

MoveNext的工作就是将Index加1，然后将新的Index指向的元素设置为当前元素currentElement，这些执行成功就返回true，否则返回false。
Reset的工作就是将Index置为-1。

Current属性则返回当前元素。

3、一个简单的自定义集合：这个就暂时先略了吧，有了上面的分析，我们通过继承CollectionBase的方法去自定义一个集合就很简单了。

三、foreach循环迭代的原理：参考http://li19910722.blog.163.com/blog/static/136856822201359105740400/

只有当一个集合实现了IEnumerable接口，才能在这个集合对象上进行foreach。由参考链接中的内容可知，其实实不实现IEnumerable接口无所谓，只要你有一个GetEnumerator方法返回一个Enumerator即可。要知道的是，Enumerator的MoveNext在将索引加1的同时，返回了true，如果到达界限则返回false，之所以返回bool值，是为了给foreach的in操作作判断用的，为真则执行循环体，否则退出循环。

但这还不够，我还是觉得有些东西没弄明白，比如迭代的时候可以用yield什么的，这其中的原理又是什么呢？看了这篇文章http://jangmon.blogbus.com/logs/36380490.html，总结一下：

foreach (Person p in persons)
{
    Console.WriteLine(p);
}
//上面的代码会被C#解析成：
IEnumerator enumerator = persons.GetEnumerator();
while (enumerator.MoveNext())
{
    Person p = (Person) enumerator.Current;
    Console.WriteLine(p);
}
//可以看出，这和我们上面的说法互补。

//定义一个HelloCollection
public class HelloCollection : IEnumerable
{
    public IEnumerator GetEnumerator()
    {
        yield return "Hello";
        yield return "World";
    }
}

//开始迭代
static void Main(string[] args)
{

    HelloCollection helloCollection=new HelloCollection ();
    foreach (string s in helloCollection )
    {
        Console.WriteLine(s);
    }
}
//HelloCollection最终转换成的代码
public class HelloCollection : IEnumerable
{
    public IEnumerator GetEnumerator()
    {
        Enumertor enumerator = new Enumerator();
        return enumerator;
    }

    public class Enumertor : IEnumerator, IDisposable
    {
        private int state;
        private object current;

        public Enumertor(int state)
        {
            this.state = state;
        }
    }
        bool System.Collections .IEnumerator .MoveNext()
        {
            switch (state)
            {
                case :
                    current = "Hello";
                    state = ;
                    return true;
                case :
                    current = "World";
                    state = ;
                    return true ;
                case :
                    break ;
            }
            return false ;
        }

        void System.Collections .IEnumerator .Reset()
        {
            throw new NotSupportedException();
        }

        object System.Collections .IEnumerator .Current
        {
            get { return current; }
        }
        void IDisposable.Dispose()
        {
        }
}

我觉得上篇文章的GetEnumerator方法在返回一个new出的Enumerator的时候，应该将state初始化为0，应该是作者是或者作者所参考的书籍的代码中的一个小错误。
GetEnumerator方法是foreach迭代默认在被迭代集合对象上调用的方法，这是可以定制的：

public class MusicTitles:IEnumerable
{
    string[] names = { "Tubular Bells", "Hergest Ridge", "Ommadawn", "Platinum" };

    public IEnumerator GetEnumerator()  /*顺序迭代*/
    {
        for (int i = ; i < ; i++)
            yield return names[i];
    }

    public IEnumerator Reverse()  /*逆序迭代*/
    {
        for (int i = ; i >= ; i--)
            yield return names[i];
    }
}

static void Main(string[] args)
{

    MusicTitles titles = new MusicTitles();
    //这个迭代没有指明，则默认就使用被迭代集合的GetEnumerator方法
    foreach (string title in titles)
    {
        Console.WriteLine(title);
    }

    Console.WriteLine();
    //这个指明了迭代所用的方法
    foreach (string title in titles.Reverse())
    {
        Console.WriteLine(title);
    }
}

四、一点体会：关于迭代，说了上面一堆，又想起Linq查询，大意是只有访问一个Element时才会作真正的查询，不知道Linq跟foreach有什么关系，日后学到了再说，反正有了一点体会，也不知道对不对：foreach跟for的区别在于，for在遍历一个集合的时候，集合中的元素必须是已经存在于内存的，而foreach由于迭代每一个项都走了MoveNext方法，从而我们可以在真正迭代到某元素的时候再临时地在MoveNext里把这个元素查出来（这取决于MoveNext的具体实现了），这似乎有一点延迟加载的味道，不知道和Linq延时查询以及EF的延时加载有什么内存关联，日后再说吧。