[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 ==  ?  : this.index > this.objArray.Length ? this.objArray.Length *  : this.objArray.Length;

             }

         }

         /// <summary>

         /// 集合实际元素个数 且只读

         /// </summary>

         public int Count

         {

             get

             {

                 return this.index;

             }

         }

         private int index;

         private object[] objArray;

         public MyArrayList()

         {

             index = ;

             //初始化0长度的数组

             this.objArray = new object[];

         }

         /// <summary>

         /// 添加元素

         /// </summary>

         /// <param name="value">元素值</param>

         public void Add(object value)

         {

             if (index >= this.objArray.Length)

             {

                 object[] newArray = index ==  ? new object[this.objArray.Length + ] : new object[this.objArray.Length * ];

                 objArray.CopyTo(newArray, );

                 objArray = newArray;

                 objArray[index++] = value;

             }

             else

             {

                 objArray[index++] = value;

             }

         }

         /// <summary>

         /// 添加数组

         /// </summary>

         /// <param name="objs"></param>

         public void AddRange(object[] objs)

         {

             for (int i = ; 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();

             list.Add();

             Console.WriteLine("count:" + list.Count);

             Console.WriteLine("Capacity:" + list.Capacity);

             list.Add();

             list.Add();

             list.Add();

             Console.WriteLine("count:" + list.Count);

             Console.WriteLine("Capacity:" + list.Capacity);

             list.Add();

             list.Add();

             list.Add();

             list.Add();

             list.Add();

             list.Add();

             Console.WriteLine("count:" + list.Count);

             Console.WriteLine("Capacity:" + list.Capacity);

             object[] arr = { , , , , ,  };

             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 = -;

         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 = -;

         }

     }

 }

测试，foreach语句，然后编译不再报错，说明已经成功了，结果如下：

这次后边不会多出逗号，原因实现了迭代器接口而迭代器继承自IDisposable接口，最后调用了Dispose()方法

代码下载，请戳这里：http://pan.baidu.com/s/1pJsGyHt

总结

foreach遍历in后面的对象需实现IEnumerable接口。

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

东西比较基础，以上是个人理解，如理解有误，请指正，以免误人子弟。

巴特西

[c#基础]集合foreach的必要条件和自定义集合

引言

自定义集合类

foreach语句

自定义集合实现IEnumerable接口

总结

最新文章

热门文章