使用Array的一个扩展类，允许Add,Remove,Contains

类代码

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; namespace DevGuideToCollections { /// <summary> /// Represents a strongly typed array. /// </summary> /// <typeparam name="T">Specifies the type of elements in the array.</typeparam> [DebuggerDisplay("Count={Count}")] [DebuggerTypeProxy(typeof(ArrayDebugView))] public class ArrayEx<T> { const int GROW_BY = 10; // Internal variable for holding the array information T[] m_data; // Contains the number of elements in the array. int m_count; int m_updateCode; /// <summary> /// Initializes a new instance of the ArrayEx(T) class that is empty. /// </summary> public ArrayEx() { Initialize(GROW_BY); } /// <summary> /// Initializes a new instance of the ArrayEx(T) class that contains the items in the array. /// </summary> /// <param name="items">Adds items to the ArrayEx(T).</param> public ArrayEx(IEnumerable<T> items) { Initialize(GROW_BY); foreach (T item in items) { Add(item); } } /// <summary> /// Initializes a new instance of the ArrayEx(T) class that is empty and has the specified initial capacity. /// </summary> /// <param name="capacity">The number of elements that the new array can initially store.</param> public ArrayEx(int capacity) { Initialize(capacity); } void Initialize(int capacity) { m_data = new T[capacity]; } /// <summary> /// States if the ArrayEx(T) is empty. /// </summary> public bool IsEmpty { get { return m_count <= 0; } } /// <summary> /// Gets the number of elements actually contained in the ArrayEx(T). /// </summary> public int Count { get { return m_count; } } /// <summary> /// Gets or sets the size of the internal data array. /// </summary> public int Capacity { get { return m_data.Length; } set { // We do not support truncating the stored array. So throw an exception if the array is less than Count. if (value < Count) { throw new ArgumentOutOfRangeException("value", "The value is less than Count"); } // We do not need to do anything if the newly specified capacity is the same as the old one. if (value == Capacity) { return; } // We will need to create a new array and move all of the values in the old array to the new one T[] tmp = new T[value]; for (int i = 0; i < Count; ++i) { tmp[i] = m_data[i]; } m_data = tmp; ++m_updateCode; } } /// <summary> /// Adds an object to the end of the ArrayEx(T). /// </summary> /// <param name="item">The item to add to the end of the ArrayEx(T).</param> public void Add(T item) { if (m_data.Length <= m_count) { Capacity += GROW_BY; } // We will need to assign the item to the last element and then increment the count variable m_data[m_count++] = item; ++m_updateCode; } /// <summary> /// Checks to see if the item is present in the ArrayEx(T). /// </summary> /// <param name="item">The item to see if the array contains.</param> /// <returns>True if the item is in the array, false if it is not.</returns> public bool Contains(T item) { EqualityComparer<T> comparer = EqualityComparer<T>.Default; for (int i = 0; i < m_count; i++) { if (comparer.Equals(m_data[i], item)) { return true; } } return false; } /// <summary> /// Gets the index of the specified item. /// </summary> /// <param name="item">The item to get the index of.</param> /// <returns>-1 if the item isn't found in the array, the index of the found item otherwise.</returns> public int IndexOf(T item) { return Array.IndexOf<T>(m_data, item, 0, m_count); } /// <summary> /// Clears all values from the ArrayEx(T). /// </summary> public void Clear() { Array.Clear(m_data, 0, m_count); ++m_updateCode; m_count = 0; } /// <summary> /// Removes the first occurrence of the specified item from the ArrayEx(T). /// </summary> /// <param name="item">The item to remove from the ArrayEx(T).</param> /// <returns>True if an item was removed, false otherwise.</returns> public bool Remove(T item) { return Remove(item, false); } /// <summary> /// Removes the first or all occurrences of the specified item from the ArrayEx(T). /// </summary> /// <param name="item">The item to remove from the ArrayEx(T).</param> /// <param name="alloccurrences">True if all occurrences of the item should be removed, False if only the first should be removed.</param> /// <returns>True if an item was removed, false otherwise.</returns> public bool Remove(T item, bool alloccurrences) { int shiftto = 0; bool shiftmode = false; bool removed = false; int count = m_count; EqualityComparer<T> comparer = EqualityComparer<T>.Default; for (int i = 0; i < count; ++i) { if (comparer.Equals(m_data[i], item) && (alloccurrences || !shiftmode)) { // Decrement the count since we have found an instance --m_count; removed = true; // Check to see if we have already found one occurrence of the item we are removing if (!shiftmode) { // We will start shifting to the position of the first occurrence. shiftto = i; // Enable shifting shiftmode = true; } continue; } if (shiftmode) { // Since we are shifting elements we need to shift the element down and then update the shiftto index to the next element. m_data[shiftto++] = m_data[i]; } } for (int i = m_count; i < count; ++i) { m_data[i] = default(T); } if (removed) { ++m_updateCode; } return removed; } /// <summary> /// Removes the item located at the specified index. /// </summary> /// <param name="index">The index of the item to remove</param> public void RemoveAt(int index) { if (index < 0 || index >= m_count) { // Item has already been removed. return; } int count = Count; // Shift all of the elements after the specified index down one. for (int i = index + 1; i < count; ++i) { m_data[i - 1] = m_data[i]; } // Decrement the count to reflect the item being removed. --m_count; ++m_updateCode; m_data[m_count] = default(T); } /// <summary> /// Inserts an item into the ArrayEx(T) at the specified index. /// </summary> /// <param name="index">The zero-based index at which item should be inserted.</param> /// <param name="item">The item to insert.</param> public void Insert(int index, T item) { if (index < 0 || index >= m_count) { throw new ArgumentOutOfRangeException("index"); } if (m_count + 1 >= Capacity) { Capacity = m_count + GROW_BY; } // First we need to shift all elements at the location up by one for (int i = m_count; i > index && i > 0; --i) { m_data[i] = m_data[i - 1]; } m_data[index] = item; ++m_count; ++m_updateCode; } /// <summary> /// Gets or sets an element in the ArrayEx(T). /// </summary> /// <param name="index">The index of the element.</param> /// <returns>The value of the element.</returns> public T this[int index] { get { if (index < 0 || index >= m_count) { throw new ArgumentOutOfRangeException("index"); } return m_data[index]; } set { if (index < 0 || index >= m_count) { throw new ArgumentOutOfRangeException("index"); } m_data[index] = value; ++m_updateCode; } } /// <summary> /// Copies the elements of the ArrayEx(T) to a new array. /// </summary> /// <returns>An array containing copies of the elements of the ArrayEx(T).</returns> public T[] ToArray() { T[] tmp = new T[Count]; for (int i = 0; i < Count; ++i) { tmp[i] = m_data[i]; } return tmp; } } }
测试方法

public static void TestArrayEx() { // Check null indexing ArrayEx<ArrayEx<int>> nullableList = new ArrayEx<ArrayEx<int>>(); nullableList = new ArrayEx<ArrayEx<int>>(); ArrayEx<int> tmpList = new ArrayEx<int>(); nullableList.Add(new ArrayEx<int>()); nullableList.Add(null); nullableList.Add(new ArrayEx<int>()); nullableList.Add(null); nullableList.Add(tmpList); nullableList.Add(null); System.Diagnostics.Debug.Assert(nullableList.Contains(null)); System.Diagnostics.Debug.Assert(nullableList.Contains(tmpList)); System.Diagnostics.Debug.Assert(!nullableList.Contains(new ArrayEx<int>())); ArrayEx<int> list = new ArrayEx<int>(); // Testing the add list.Add(1); list.Add(3); list.Add(4); list.Add(6); list.Add(9); list.Add(5); list.Add(6); list.Add(9); list.Add(9); list.Add(7); List<int> tt = new List<int>(new int[] {1, 3, 4}) ; System.Diagnostics.Debug.Assert(list.Count == 10); // Testing the grow by list.Add(14); list.Add(19); System.Diagnostics.Debug.Assert(list.Count == 12); // Deleting the first 6 from the list list.Remove(6, false); System.Diagnostics.Debug.Assert(list.Contains(6)); System.Diagnostics.Debug.Assert(list.IndexOf(6) == 5); System.Diagnostics.Debug.Assert(list.Count == 11); // Deleting all 9s from the list list.Remove(9, true); System.Diagnostics.Debug.Assert(!list.Contains(9)); System.Diagnostics.Debug.Assert(list.Count == 8); // Inserting a two at the 2nd position list.Insert(1, 2); System.Diagnostics.Debug.Assert(list[1] == 2); System.Diagnostics.Debug.Assert(list[2] == 3); System.Diagnostics.Debug.Assert(list.Count == 9); // Check the DebugView method ArrayDebugView view = new ArrayDebugView(list); object[] values = view.Items; System.Diagnostics.Debug.Assert(values.Length == list.Count); for (int i = 0; i < list.Count; ++i) { System.Diagnostics.Debug.Assert((int)values[i] == list[i]); } // Testing clear list.Clear(); System.Diagnostics.Debug.Assert(list.Count == 0); list.Add(66); list.Add(99); System.Diagnostics.Debug.Assert(list[0] == 66); System.Diagnostics.Debug.Assert(list[1] == 99); // Test removing System.Diagnostics.Debug.Assert(list.Remove(66)); System.Diagnostics.Debug.Assert(!list.Remove(68)); // Prepare for RemoveAt test list.Clear(); list.Add(0); list.Add(1); list.Add(2); list.Add(3); list.Add(4); list.Add(5); list.Add(6); list.Add(7); System.Diagnostics.Debug.Assert(list.Count == 8); // Test RemoveAt the end list.RemoveAt(7); System.Diagnostics.Debug.Assert(list.Count == 7); System.Diagnostics.Debug.Assert(list.Contains(6)); System.Diagnostics.Debug.Assert(!list.Contains(7)); // Test RemoveAt the middle list.RemoveAt(4); System.Diagnostics.Debug.Assert(list.Count == 6); System.Diagnostics.Debug.Assert(list.Contains(3)); System.Diagnostics.Debug.Assert(list.Contains(5)); System.Diagnostics.Debug.Assert(!list.Contains(4)); // Test RemoveAt the front list.RemoveAt(0); System.Diagnostics.Debug.Assert(list.Count == 5); System.Diagnostics.Debug.Assert(list.Contains(1)); System.Diagnostics.Debug.Assert(!list.Contains(0)); }