求助C#作业

Question

编写一个集合类
1、是否实现IList接口自行决定
2、如果实现IList接口，则接口功能自行编写，不得继承现有类如ArrayList
3、长度可以自动生长和收缩

Answer 1

1楼说来简单，你貌似很牛逼嘛，你写个实现Ilist试试我看看，
说实话下面这个是微软的ArrayList类实现文件，我用反编译查看了下发现直接改名给你有些不负责任，因为微软的ArrayList同时实现了集合IConllection，许多访问是为了保存线程安全做的，感觉没必要都贴出来就删除了一部分无关的代码，留下的仅仅是个可以用实现foreach必须接口IEnumerable和IList的插入删除等等自扩充功能，这个目前还不是泛型，你可以发现内容依然是个object数组，因此这里当你用索引器访问时存在装箱的可能，如果你想实现List<T>泛型模式，那么这个内部数组也要支持泛型，不过好处是速度 快了，呵呵。
using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Threading;
public class WorkList : IList, IEnumerable
{
private const int _defaultCapacity = 4;
private object[] _items;
private int _size;
private static readonly object[] emptyArray = new object[0];

public WorkList()
{
this._items = emptyArray;
}

public WorkList(int capacity)
{
if (capacity < 0)
{
throw new ArgumentOutOfRangeException("capacity", Environment.GetResourceString("ArgumentOutOfRange_MustBeNonNegNum", new object[] { "capacity" }));
}
this._items = new object[capacity];
}

public virtual int Add(object value)
{
if (this._size == this._items.Length)
{
this.EnsureCapacity(this._size + 1);
}
this._items[this._size] = value;
return this._size++;
}

public virtual void Clear()
{
Array.Clear(this._items, 0, this._size);
this._size = 0;
}

public virtual bool Contains(object item)
{
if (item == null)
{
for (int j = 0; j < this._size; j++)
{
if (this._items[j] == null)
{
return true;
}
}
return false;
}
for (int i = 0; i < this._size; i++)
{
if ((this._items[i] != null) && this._items[i].Equals(item))
{
return true;
}
}
return false;
}

public virtual void CopyTo(Array array)
{
this.CopyTo(array, 0);
}

public virtual void CopyTo(Array array, int arrayIndex)
{
if ((array != null) && (array.Rank != 1))
{
throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
}
Array.Copy(this._items, 0, array, arrayIndex, this._size);
}

public virtual void CopyTo(int index, Array array, int arrayIndex, int count)
{
if ((this._size - index) < count)
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
}
if ((array != null) && (array.Rank != 1))
{
throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
}
Array.Copy(this._items, index, array, arrayIndex, count);
}

private void EnsureCapacity(int min)
{
if (this._items.Length < min)
{
int num = (this._items.Length == 0) ? 4 : (this._items.Length * 2);
if (num < min)
{
num = min;
}
this.Capacity = num;
}
}

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

public virtual IEnumerator GetEnumerator(int index, int count)
{
if ((index < 0) || (count < 0))
{
throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if ((this._size - index) < count)
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
}
return new WorkListEnumerator(this, index, count);
}

public virtual int IndexOf(object value)
{
return Array.IndexOf(this._items, value, 0, this._size);
}

public virtual int IndexOf(object value, int startIndex)
{
if (startIndex > this._size)
{
throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
return Array.IndexOf(this._items, value, startIndex, this._size - startIndex);
}

public virtual int IndexOf(object value, int startIndex, int count)
{
if (startIndex > this._size)
{
throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
if ((count < 0) || (startIndex > (this._size - count)))
{
throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Count"));
}
return Array.IndexOf(this._items, value, startIndex, count);
}

public virtual void Insert(int index, object value)
{
if ((index < 0) || (index > this._size))
{
throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_WorkListInsert"));
}
if (this._size == this._items.Length)
{
this.EnsureCapacity(this._size + 1);
}
if (index < this._size)
{
Array.Copy(this._items, index, this._items, index + 1, this._size - index);
}
this._items[index] = value;
this._size++;
this._version++;
}

public virtual int LastIndexOf(object value)
{
return this.LastIndexOf(value, this._size - 1, this._size);
}

public virtual int LastIndexOf(object value, int startIndex)
{
if (startIndex >= this._size)
{
throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
return this.LastIndexOf(value, startIndex, startIndex + 1);
}

public virtual int LastIndexOf(object value, int startIndex, int count)
{
if (this._size == 0)
{
return -1;
}
if ((startIndex < 0) || (count < 0))
{
throw new ArgumentOutOfRangeException((startIndex < 0) ? "startIndex" : "count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if ((startIndex >= this._size) || (count > (startIndex + 1)))
{
throw new ArgumentOutOfRangeException((startIndex >= this._size) ? "startIndex" : "count", Environment.GetResourceString("ArgumentOutOfRange_BiggerThanCollection"));
}
return Array.LastIndexOf(this._items, value, startIndex, count);
}

public virtual void Remove(object obj)
{
int index = this.IndexOf(obj);
if (index >= 0)
{
this.RemoveAt(index);
}
}

public virtual void RemoveAt(int index)
{
if ((index < 0) || (index >= this._size))
{
throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
this._size--;
if (index < this._size)
{
Array.Copy(this._items, index + 1, this._items, index, this._size - index);
}
this._items[this._size] = null;
this._version++;
}

public virtual int Capacity
{
get
{
return this._items.Length;
}
set
{
if (value != this._items.Length)
{
if (value < this._size)
{
throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
}
if (value > 0)
{
object[] destinationArray = new object[value];
if (this._size > 0)
{
Array.Copy(this._items, 0, destinationArray, 0, this._size);
}
this._items = destinationArray;
}
else
{
this._items = new object[4];
}
}
}
}

public virtual int Count
{
get
{
return this._size;
}
}

public virtual bool IsSynchronized
{
get
{
return false;
}
}

public virtual object this[int index]
{
get
{
if ((index < 0) || (index >= this._size))
{
throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
return this._items[index];
}
set
{
if ((index < 0) || (index >= this._size))
{
throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
}
this._items[index] = value;
this._version++;
}
}

[Serializable]
private sealed class WorkListEnumerator : IEnumerator, ICloneable
{
private object currentElement;
private int endIndex;
private int index;
private WorkList list;
private int startIndex;
private int version;

internal WorkListEnumerator(WorkList list, int index, int count)
{
this.list = list;
this.startIndex = index;
this.index = index - 1;
this.endIndex = this.index + count;
this.version = list._version;
this.currentElement = null;
}

public object Clone()
{
return base.MemberwiseClone();
}

public bool MoveNext()
{
if (this.version != this.list._version)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumFailedVersion"));
}
if (this.index < this.endIndex)
{
this.currentElement = this.list[++this.index];
return true;
}
this.index = this.endIndex + 1;
return false;
}

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

public object Current
{
get
{
if (this.index < this.startIndex)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumNotStarted"));
}
if (this.index > this.endIndex)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumEnded"));
}
return this.currentElement;
}
}
}

[Serializable]
private sealed class WorkListEnumeratorSimple : IEnumerator, ICloneable
{
private object currentElement;
private static object dummyObject = new object();
private int index;
[NonSerialized]
private bool isWorkList;
private WorkList list;
private int version;

internal WorkListEnumeratorSimple(WorkList list)
{
this.list = list;
this.index = -1;
this.version = list._version;
this.isWorkList = list.GetType() == typeof(WorkList);
this.currentElement = dummyObject;
}

public object Clone()
{
return base.MemberwiseClone();
}

public bool MoveNext()
{
if (this.version != this.list._version)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumFailedVersion"));
}
if (this.isWorkList)
{
if (this.index < (this.list._size - 1))
{
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 - 1))
{
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 = -1;
}

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

Answer 2

可以参考江湖新秀的建议，不错！
IList可以实现这类的集合

Answer 3

写个类继承Ilist 接口不就完了

Answer 4

IList<>泛型试下