[c#基礎]集合foreach的必要條件和自定義集合

引言

最近翻看了之前的學習筆記，看到foreach，記得當時老師講的時候，有點犯渾，不是很明白，這好比，上小學時，你不會乘法口訣，但是隨着時間的增長，你不自覺的都會了，也悟出個小道理，有些東西，你當時不太懂，但隨着你的閱歷和經驗的增長，有那么一天你會恍然大悟，哦，原來是這樣。

自定義集合類

提到foreach就不得不說集合，那么就先從自定義的集合開始吧。

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

namespace Wolfy.自定義集合
{
    /// <summary>
    /// 自定義集合類
    /// </summary>
    public class MyArrayList
    {
        /// <summary>
        /// 集合的容量屬性 成倍數增加0，4，8，且只讀
        /// </summary>
        public int Capacity
        {
            get
            {
                return this.objArray.Length == 0 ? 0 : this.index > this.objArray.Length ? this.objArray.Length * 2 : this.objArray.Length;
            }
        }
        /// <summary>
        /// 集合實際元素個數 且只讀
        /// </summary>
        public int Count
        {
            get
            {
                return this.index;
            }
        }
        private int index;
        private object[] objArray;
        public MyArrayList()
        {
            index = 0;
            //初始化0長度的數組
            this.objArray = new object[0];
        }
        /// <summary>
        /// 添加元素
        /// </summary>
        /// <param name="value">元素值</param>
        public void Add(object value)
        {
            if (index >= this.objArray.Length)
            {
                object[] newArray = index == 0 ? new object[this.objArray.Length + 4] : new object[this.objArray.Length * 2];
                objArray.CopyTo(newArray, 0);
                objArray = newArray;
                objArray[index++] = value;
            }
            else
            {
                objArray[index++] = value;
            }
        }
        /// <summary>
        /// 添加數組
        /// </summary>
        /// <param name="objs"></param>
        public void AddRange(object[] objs)
        {
            for (int i = 0; i < objs.Length; i++)
            {
                this.Add(objs[i]);
            }
        }
    }
}

不知道自定義的集合和ArrayList是否一樣，可以簡單的測試一下。

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

namespace Wolfy.自定義集合
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();
            //MyArrayList list = new MyArrayList();
            Console.WriteLine("count:" + list.Count);
            Console.WriteLine("Capacity:" + list.Capacity);
            list.Add(1);
            list.Add(1);
            Console.WriteLine("count:" + list.Count);
            Console.WriteLine("Capacity:" + list.Capacity);
            list.Add(1);
            list.Add(1);
            list.Add(1);
            Console.WriteLine("count:" + list.Count);
            Console.WriteLine("Capacity:" + list.Capacity);
            list.Add(1);
            list.Add(1);
            list.Add(1);
            list.Add(1);
            list.Add(1);
            list.Add(1);
            Console.WriteLine("count:" + list.Count);
            Console.WriteLine("Capacity:" + list.Capacity);
            object[] arr = { 1, 2, 3, 4, 5, 6 };
            list.AddRange(arr);
            Console.WriteLine("count:" + list.Count);
            Console.WriteLine("Capacity:" + list.Capacity);
            Console.Read();
        }
    }
}

此時是.Net中的ArrayList，結果：

自定義的集合，結果：

輸出結果一樣，那么現在用foreach遍歷，自定義集合中的元素。F6編譯，會提示錯誤。

foreach語句

 其實foreach是怎樣工作的呢？

眾所周知foreach中in后面的對象應該是實現IEnumerable接口的，程序運行時本質是在調用IEnumerable的GetEnumerator函數來返回一個IEnumerator對象，foreach就是利用IEnumerator對象的Current，MoveNext和Reset成員來進行一段數據的枚舉。簡單的代碼實現如下：

            //System.Collections下的IEnumerator
            IEnumerator enumerator = this.objArray.GetEnumerator();
            while (enumerator.MoveNext())
            {
                Console.WriteLine(enumerator.Current);
            }

將這個代碼放在自定義集合中，定義一個方法GetArray(),然后測試一下

        /// <summary>
        /// 得到所有的元素
        /// </summary>
        public void GetArray()
        {
            //System.Collections下的IEnumerator
            IEnumerator enumerator = this.objArray.GetEnumerator();
            while (enumerator.MoveNext())
            {
                Console.Write(enumerator.Current+“,”);
            }
        }

測試結果：

你運行會發現多出很多逗號，原因是執行后，enumerator沒有被Dispose掉，而繼承IDisposable的迭代器（IEnumerator）在foreach結束后會被正確處理掉（調用Dispose方法）。

自定義集合實現IEnumerable接口

實現IEnumerable接口必須實現它里面的成員GetEnumerator()方法：

        public IEnumerator GetEnumerator()
        {
            throw new NotImplementedException();
        }

該方法的返回值為實現了IEnumerator接口的類的對象。那么現在需要定義一個實現了該接口的類。

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

namespace Wolfy.自定義集合
{
    public class MyEnumerator : IEnumerator
    {
        /// <summary>
        /// 返回當前指針指向的元素的值
        /// </summary>
        public object Current
        {
            get { throw new NotImplementedException(); }
        }
        /// <summary>
        /// 將指針向前移動1位，並判斷當前位有沒有元素.指針默認在-1位置
        /// </summary>
        /// <returns></returns>
        public bool MoveNext()
        {
            throw new NotImplementedException();
        }
        /// <summary>
        /// 重置
        /// </summary>
        public void Reset()
        {
            throw new NotImplementedException();
        }
    }
}

迭代需要數組參數，在構造函數中將自定義集合中的數組傳進來，並且在MoveNext中需要判斷指針是否移動到數組的末尾，那么需要數組的長度。
MyArrayList中GetEnumerator()方法實現

        public IEnumerator GetEnumerator()
        {
            return new MyEnumerator(this.objArray, this.Count);
        }

MyEnumerator類

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

namespace Wolfy.自定義集合
{
    public class MyEnumerator : IEnumerator
    {
        /// <summary>
        /// 指針的默認位置
        /// </summary>
        private int index = -1;
        private object[] objArray;
        /// <summary>
        /// 數組長度
        /// </summary>
        private int count;
        public MyEnumerator(object[] objArray, int count)
        {

            this.objArray = objArray;
            this.count = count;
        }
        /// <summary>
        /// 返回當前指針指向的元素的值
        /// </summary>
        public object Current
        {
            get { return this.objArray[index]; }
        }
        /// <summary>
        /// 將指針向前移動1位，並判斷當前位有沒有元素.指針默認在-1位置
        /// </summary>
        /// <returns></returns>
        public bool MoveNext()
        {
            index++;//指針首先向前移動一位
            if (index < this.count)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 重置
        /// </summary>
        public void Reset()
        {
            index = -1;
        }
    }
}

測試，foreach語句，然后編譯不再報錯，說明已經成功了，結果如下：

這次后邊不會多出逗號，原因實現了迭代器接口而迭代器繼承自IDisposable接口，最后調用了Dispose()方法

代碼下載，請戳這里：http://pan.baidu.com/s/1pJsGyHt

總結

foreach遍歷in后面的對象需實現IEnumerable接口。

迭代器概念可參考：http://msdn.microsoft.com/zh-cn/library/dscyy5s0(VS.80).aspx

東西比較基礎，以上是個人理解，如理解有誤，請指正，以免誤人子弟。