模仿.NET框架ArrayList写一个自己的动态数组类MyArrayList，揭示foreach实现原理

通过.NET反编译工具可以查看到ArrayList内部的代码，发现ArrayList并非由链表实现，而是由一个不断扩容的数组对象组成。

下面模仿ArrayList写一个自己的MyArrayList。

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace 模仿动态数组

{

/// <summary>

/// 模拟ArrayList类

/// </summary>

class MyArrayList

{

/// <summary>

/// 初始化MyArraiList的新实例，用默认的初始值初始化动态数组

/// </summary>

public MyArrayList()

{

//将容量属性初始值设为0

Capacity = 0;

//实例化一个新的数组实例

arr = new object[Capacity];

//定义数组索引为0

Index = 0;

}

/// <summary>

/// 初始化MyArrayList, 用指针的容量初始化动态数组，如果参数小于0，则抛出异常

/// </summary>

/// <param name="capacity">指定要初始化动态数组的大小</param>

public MyArrayList(int capacity)

{

//判断传入的容量是否合法

if (capacity < 0)

{

//如果参数不合法，抛出异常

throw new ArgumentOutOfRangeException("capacity", "capacity must not less than zero!");

}

//如果参数合法，用指定的大小初始化数组

this.arr = new object[capacity];

}

/// <summary>

/// 成员属性：数组引用

/// </summary>

private object[] arr;

/// <summary>

/// 成员属性：数组当前指针

/// </summary>

public int Index { get; set; }

/// <summary>

/// 成员属性：数组容量

/// </summary>

public int Capacity { get; set; }

/// <summary>

/// 构造一个索引器

/// </summary>

/// <param name="index">指定的索引值</param>

/// <returns>返回当前索引下数组的值</returns>

public object this[int index]

{

get

{

return arr[index];

}

set

{

//判断参数是否合法

if (index < 0 || index >= Index)

{

//如果不合法，抛出异常

throw new ArgumentOutOfRangeException("index", "index must be not less than 0 and not biger than index");

}

//否则，赋值

arr[index] = value;

}

}

/// <summary>

/// 成员方法：添加元素

/// </summary>

/// <param name="value"></param>

public void Add(object value)

{

//判断当前索引是否小于数组长度

if (Index < arr.Length)

{

//如果小于数组长度，则添加

arr[Index++] = value;

}

else

{

//如果超出数组长度-1

Capacity = arr.Length * 2;

//创建一个比当前数组大两倍的数组

object[] newArr = new object[arr.Length*2];

//将就数组的数据拷贝到新数组中

Array.Copy(arr, newArr,arr.Length);

//就数组的引用指向新的数组

arr = newArr;

//添加元素

arr[Index++] = value;

}

}

}

}

MyArrayList list = new MyArrayList();

//往动态数组中添加对象

For (int I = 0; I < 10; i++)

{

List.Add(i);

}

//遍历

foreach (object val in list)

{

Console.WriteLine(val);

}

发现这里出错了，为什么.Net Framework里的ArrayList对象可以用foreach遍历，而我们自己写的却不行

通过CSDN的介绍可知，

Foreach()等同于如下代码

IEnumerator  tor = new list. GetEnumerator();

While (list.MoveNext())

{

Console.WriteLine(list.Current);

}

foreach内部实际上调用对象内部的GetEnumerator()方法将动态数组封装成迭代器

GetEnumerator()也就是工厂函数，通过传入的arr和count生成迭代器对象

而GetEnumerator()来自于 IEnumerable接口。因此要想让foreach遍历自己写的动态数组类，必须实现IEnumerable接口。

该接口中的GetEnumerator要求返回一个对象，而且返回的是对象的父类，所以必须写一个迭代器对象的类，并且实现了IEnumerator，这样就可以在外部通过IEnumerator类型的变量调用它指向它的子类中实现了的方法。

基于此，我们来实现这个接口，代码如下：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace 模仿动态数组

{

/// <summary>

/// 模拟ArrayList类

/// </summary>

class MyArrayList:IEnumerable

{

/// <summary>

/// 初始化MyArraiList的新实例，用默认的初始值初始化动态数组

/// </summary>

public MyArrayList()

{

//将容量属性初始值设为0

Capacity = 0;

//实例化一个新的数组实例

arr = new object[Capacity];

//定义数组索引为0

Index = 0;

}

/// <summary>

/// 初始化MyArrayList, 用指针的容量初始化动态数组，如果参数小于0，则抛出异常

/// </summary>

/// <param name="capacity">指定要初始化动态数组的大小</param>

public MyArrayList(int capacity)

{

//判断传入的容量是否合法

if (capacity < 0)

{

//如果参数不合法，抛出异常

throw new ArgumentOutOfRangeException("capacity", "capacity must not less than zero!");

}

//如果参数合法，用指定的大小初始化数组

this.arr = new object[capacity];

}

/// <summary>

/// 成员属性：数组引用

/// </summary>

private object[] arr;

/// <summary>

/// 成员属性：数组当前指针

/// </summary>

public int Index { get; set; }

/// <summary>

/// 成员属性：数组容量

/// </summary>

public int Capacity { get; set; }

/// <summary>

/// 构造一个索引器

/// </summary>

/// <param name="index">指定的索引值</param>

/// <returns>返回当前索引下数组的值</returns>

public object this[int index]

{

get

{

return arr[index];

}

set

{

//判断参数是否合法

if (index < 0 || index >= Index)

{

//如果不合法，抛出异常

throw new ArgumentOutOfRangeException("index", "index must be not less than 0 and not biger than index");

}

//否则，赋值

arr[index] = value;

}

}

/// <summary>

/// 成员方法：添加元素

/// </summary>

/// <param name="value"></param>

public void Add(object value)

{

//判断当前索引是否小于数组长度

if (Index < arr.Length)

{

//如果小于数组长度，则添加

arr[Index++] = value;

}

else

{

//如果超出数组长度-1

Capacity = arr.Length * 2;

//创建一个比当前数组大两倍的数组

object[] newArr = new object[arr.Length*2];

//将就数组的数据拷贝到新数组中

Array.Copy(arr, newArr,arr.Length);

//就数组的引用指向新的数组

arr = newArr;

//添加元素

arr[Index++] = value;

}

}

/// <summary>

/// 返回一个迭代器对象

/// </summary>

/// <returns>返回一个迭代器对象</returns>

public IEnumerator GetEnumerator()

{

return new MyIEnumerator(arr, Index);

}

}

}

接着完成 迭代器对象的类

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace 模仿动态数组

{

/// <summary>

/// 一个迭代器的类，用来处理实现了ICollection接口的数组类

/// </summary>

class MyIEnumerator:IEnumerator

{

private object[] arr;

private int count;

private int index;

/// <summary>

/// 初始化MyIEnumerator的新实例，以指定的arr和count(数组实际长度，非容量)

/// </summary>

/// <param name="arr"></param>

/// <param name="count"></param>

public MyIEnumerator(object[] arr, int count)

{

this.arr = arr;

this.count = count;

//当前指针在首位

this.index = -1;

}

/// <summary>

/// 成员属性（只读）：返回当前指针指向的元素

/// </summary>

public object Current

{

get

{

return arr[index];

}

}

/// <summary>

/// 成员方法：移动指针，判断当前指针指向的数是否合法

/// </summary>

/// <returns></returns>

public bool MoveNext()

{

index++;

return index < count;

}

/// <summary>

/// 成员方法：将当前数组指针重置为第一个元素之前

/// </summary>

public void Reset()

{

index = -1;

}

}

}

好了，这时再用foreach遍历我们自己的数组，看到效果了吧。

MyArrayList list = new MyArrayList();

List.Add(1);

List.Add(2);

List.Add(3);

List.Add(4);

List.Add(5);

Foreach (object val in list)

{

Console.WriteLine(val);

}

输出

1

2

3

4

5