We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Collections \ IListWrapperEnumWrapper

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*============================================================
  16. **
  17. ** Class:  ArrayList
  18. **
  19. **
  20. ** Purpose: Implements a dynamically sized List as an array,
  21. **          and provides many convenience methods for treating
  22. **          an array as an IList.
  23. **
  24. **
  25. ===========================================================*/
  26. namespace System.Collections
  27. {
  28.     using System;
  29.     using System.Security.Permissions;
  30.     using System.Diagnostics;
  31.     using System.Runtime.Serialization;
  32.    
  33.     // Implements a variable-size List that uses an array of objects to store the
  34.     // elements. A ArrayList has a capacity, which is the allocated length
  35.     // of the internal array. As elements are added to a ArrayList, the capacity
  36.     // of the ArrayList is automatically increased as required by reallocating the
  37.     // internal array.
  38.     //
  39.     [DebuggerTypeProxy(typeof(System.Collections.ArrayList.ArrayListDebugView))]
  40.     [DebuggerDisplay("Count = {Count}")]
  41.     [Serializable()]
  42.     [System.Runtime.InteropServices.ComVisible(true)]
  43.     public class ArrayList : IList, ICloneable
  44.     {
  45.         private object[] _items;
  46.         private int _size;
  47.         private int _version;
  48.         [NonSerialized()]
  49.         private object _syncRoot;
  50.        
  51.         private const int _defaultCapacity = 4;
  52.         private static readonly object[] emptyArray = new object[0];
  53.        
  54.         // Note: this constructor is a bogus constructor that does nothing
  55.         // and is for use only with SyncArrayList.
  56.         internal ArrayList(bool trash)
  57.         {
  58.         }
  59.        
  60.         // Constructs a ArrayList. The list is initially empty and has a capacity
  61.         // of zero. Upon adding the first element to the list the capacity is
  62.         // increased to _defaultCapacity, and then increased in multiples of two as required.
  63.         public ArrayList()
  64.         {
  65.             _items = emptyArray;
  66.         }
  67.        
  68.         // Constructs a ArrayList with a given initial capacity. The list is
  69.         // initially empty, but will have room for the given number of elements
  70.         // before any reallocations are required.
  71.         //
  72.         public ArrayList(int capacity)
  73.         {
  74.             if (capacity < 0)
  75.                 throw new ArgumentOutOfRangeException("capacity", Environment.GetResourceString("ArgumentOutOfRange_MustBeNonNegNum", "capacity"));
  76.             _items = new object[capacity];
  77.         }
  78.        
  79.         // Constructs a ArrayList, copying the contents of the given collection. The
  80.         // size and capacity of the new list will both be equal to the size of the
  81.         // given collection.
  82.         //
  83.         public ArrayList(ICollection c)
  84.         {
  85.             if (c == null)
  86.                 throw new ArgumentNullException("c", Environment.GetResourceString("ArgumentNull_Collection"));
  87.             _items = new object[c.Count];
  88.             AddRange(c);
  89.         }
  90.        
  91.         // Gets and sets the capacity of this list. The capacity is the size of
  92.         // the internal array used to hold items. When set, the internal
  93.         // array of the list is reallocated to the given capacity.
  94.         //
  95.         public virtual int Capacity {
  96.             get { return _items.Length; }
  97.             set {
  98.                 // We don't want to update the version number when we change the capacity.
  99.                 // Some existing applications have dependency on this.
  100.                 if (value != _items.Length) {
  101.                     if (value < _size) {
  102.                         throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
  103.                     }
  104.                    
  105.                     if (value > 0) {
  106.                         object[] newItems = new object[value];
  107.                         if (_size > 0) {
  108.                             Array.Copy(_items, 0, newItems, 0, _size);
  109.                         }
  110.                         _items = newItems;
  111.                     }
  112.                     else {
  113.                         _items = new object[_defaultCapacity];
  114.                     }
  115.                 }
  116.             }
  117.         }
  118.        
  119.         // Read-only property describing how many elements are in the List.
  120.         public virtual int Count {
  121.             get { return _size; }
  122.         }
  123.        
  124.         public virtual bool IsFixedSize {
  125.             get { return false; }
  126.         }
  127.        
  128.        
  129.         // Is this ArrayList read-only?
  130.         public virtual bool IsReadOnly {
  131.             get { return false; }
  132.         }
  133.        
  134.         // Is this ArrayList synchronized (thread-safe)?
  135.         public virtual bool IsSynchronized {
  136.             get { return false; }
  137.         }
  138.        
  139.         // Synchronization root for this object.
  140.         public virtual object SyncRoot {
  141.             get {
  142.                 if (_syncRoot == null) {
  143.                     System.Threading.Interlocked.CompareExchange(ref _syncRoot, new object(), null);
  144.                 }
  145.                 return _syncRoot;
  146.             }
  147.         }
  148.        
  149.         // Sets or Gets the element at the given index.
  150.         //
  151.         public virtual object this[int index]
  152.         {
  153.             get {
  154.                 if (index < 0 || index >= _size)
  155.                     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  156.                 return _items[index];
  157.             }
  158.             set {
  159.                 if (index < 0 || index >= _size)
  160.                     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  161.                 _items[index] = value;
  162.                 _version++;
  163.             }
  164.         }
  165.        
  166.         // Creates a ArrayList wrapper for a particular IList. This does not
  167.         // copy the contents of the IList, but only wraps the ILIst. So any
  168.         // changes to the underlying list will affect the ArrayList. This would
  169.         // be useful if you want to Reverse a subrange of an IList, or want to
  170.         // use a generic BinarySearch or Sort method without implementing one yourself.
  171.         // However, since these methods are generic, the performance may not be
  172.         // nearly as good for some operations as they would be on the IList itself.
  173.         //
  174.         public static ArrayList Adapter(IList list)
  175.         {
  176.             if (list == null)
  177.                 throw new ArgumentNullException("list");
  178.             return new IListWrapper(list);
  179.         }
  180.        
  181.         // Adds the given object to the end of this list. The size of the list is
  182.         // increased by one. If required, the capacity of the list is doubled
  183.         // before adding the new element.
  184.         //
  185.         public virtual int Add(object value)
  186.         {
  187.             if (_size == _items.Length)
  188.                 EnsureCapacity(_size + 1);
  189.             _items[_size] = value;
  190.             _version++;
  191.             return _size++;
  192.         }
  193.        
  194.         // Adds the elements of the given collection to the end of this list. If
  195.         // required, the capacity of the list is increased to twice the previous
  196.         // capacity or the new size, whichever is larger.
  197.         //
  198.         public virtual void AddRange(ICollection c)
  199.         {
  200.             InsertRange(_size, c);
  201.         }
  202.        
  203.         // Searches a section of the list for a given element using a binary search
  204.         // algorithm. Elements of the list are compared to the search value using
  205.         // the given IComparer interface. If comparer is null, elements of
  206.         // the list are compared to the search value using the IComparable
  207.         // interface, which in that case must be implemented by all elements of the
  208.         // list and the given search value. This method assumes that the given
  209.         // section of the list is already sorted; if this is not the case, the
  210.         // result will be incorrect.
  211.         //
  212.         // The method returns the index of the given value in the list. If the
  213.         // list does not contain the given value, the method returns a negative
  214.         // integer. The bitwise complement operator (~) can be applied to a
  215.         // negative result to produce the index of the first element (if any) that
  216.         // is larger than the given search value. This is also the index at which
  217.         // the search value should be inserted into the list in order for the list
  218.         // to remain sorted.
  219.         //
  220.         // The method uses the Array.BinarySearch method to perform the
  221.         // search.
  222.         //
  223.         public virtual int BinarySearch(int index, int count, object value, IComparer comparer)
  224.         {
  225.             if (index < 0 || count < 0)
  226.                 throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  227.             if (_size - index < count)
  228.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  229.            
  230.             return Array.BinarySearch((Array)_items, index, count, value, comparer);
  231.         }
  232.        
  233.         public virtual int BinarySearch(object value)
  234.         {
  235.             return BinarySearch(0, Count, value, null);
  236.         }
  237.        
  238.         public virtual int BinarySearch(object value, IComparer comparer)
  239.         {
  240.             return BinarySearch(0, Count, value, comparer);
  241.         }
  242.        
  243.        
  244.         // Clears the contents of ArrayList.
  245.         public virtual void Clear()
  246.         {
  247.             Array.Clear(_items, 0, _size);
  248.             // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
  249.             _size = 0;
  250.             _version++;
  251.         }
  252.        
  253.         // Clones this ArrayList, doing a shallow copy. (A copy is made of all
  254.         // Object references in the ArrayList, but the Objects pointed to
  255.         // are not cloned).
  256.         public virtual object Clone()
  257.         {
  258.             ArrayList la = new ArrayList(_size);
  259.             la._size = _size;
  260.             la._version = _version;
  261.             Array.Copy(_items, 0, la._items, 0, _size);
  262.             return la;
  263.         }
  264.        
  265.        
  266.         // Contains returns true if the specified element is in the ArrayList.
  267.         // It does a linear, O(n) search. Equality is determined by calling
  268.         // item.Equals().
  269.         //
  270.         public virtual bool Contains(object item)
  271.         {
  272.             if (item == null) {
  273.                 for (int i = 0; i < _size; i++)
  274.                     if (_items[i] == null)
  275.                         return true;
  277.                 return false;
  278.             }
  279.             else {
  280.                 for (int i = 0; i < _size; i++)
  281.                     if ((_items[i] != null) && (_items[i].Equals(item)))
  282.                         return true;
  284.                 return false;
  285.             }
  286.         }
  287.        
  288.         // Copies this ArrayList into array, which must be of a
  289.         // compatible array type.
  290.         //
  291.         public virtual void CopyTo(Array array)
  292.         {
  293.             CopyTo(array, 0);
  294.         }
  295.        
  296.         // Copies this ArrayList into array, which must be of a
  297.         // compatible array type.
  298.         //
  299.         public virtual void CopyTo(Array array, int arrayIndex)
  300.         {
  301.             if ((array != null) && (array.Rank != 1))
  302.                 throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
  303.             // Delegate rest of error checking to Array.Copy.
  304.             Array.Copy(_items, 0, array, arrayIndex, _size);
  305.         }
  306.        
  307.         // Copies a section of this list to the given array at the given index.
  308.         //
  309.         // The method uses the Array.Copy method to copy the elements.
  310.         //
  311.         public virtual void CopyTo(int index, Array array, int arrayIndex, int count)
  312.         {
  313.             if (_size - index < count)
  314.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  315.             if ((array != null) && (array.Rank != 1))
  316.                 throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
  317.             // Delegate rest of error checking to Array.Copy.
  318.             Array.Copy(_items, index, array, arrayIndex, count);
  319.         }
  320.        
  321.         // Ensures that the capacity of this list is at least the given minimum
  322.         // value. If the currect capacity of the list is less than min, the
  323.         // capacity is increased to twice the current capacity or to min,
  324.         // whichever is larger.
  325.         private void EnsureCapacity(int min)
  326.         {
  327.             if (_items.Length < min) {
  328.                 int newCapacity = _items.Length == 0 ? _defaultCapacity : _items.Length * 2;
  329.                 if (newCapacity < min)
  330.                     newCapacity = min;
  331.                 Capacity = newCapacity;
  332.             }
  333.         }
  334.        
  335.         // Returns a list wrapper that is fixed at the current size. Operations
  336.         // that add or remove items will fail, however, replacing items is allowed.
  337.         //
  338.         public static IList FixedSize(IList list)
  339.         {
  340.             if (list == null)
  341.                 throw new ArgumentNullException("list");
  342.             return new FixedSizeList(list);
  343.         }
  344.        
  345.         // Returns a list wrapper that is fixed at the current size. Operations
  346.         // that add or remove items will fail, however, replacing items is allowed.
  347.         //
  348.         public static ArrayList FixedSize(ArrayList list)
  349.         {
  350.             if (list == null)
  351.                 throw new ArgumentNullException("list");
  352.             return new FixedSizeArrayList(list);
  353.         }
  354.        
  355.         // Returns an enumerator for this list with the given
  356.         // permission for removal of elements. If modifications made to the list
  357.         // while an enumeration is in progress, the MoveNext and
  358.         // GetObject methods of the enumerator will throw an exception.
  359.         //
  360.         public virtual IEnumerator GetEnumerator()
  361.         {
  362.             return new ArrayListEnumeratorSimple(this);
  363.         }
  364.        
  365.         // Returns an enumerator for a section of this list with the given
  366.         // permission for removal of elements. If modifications made to the list
  367.         // while an enumeration is in progress, the MoveNext and
  368.         // GetObject methods of the enumerator will throw an exception.
  369.         //
  370.         public virtual IEnumerator GetEnumerator(int index, int count)
  371.         {
  372.             if (index < 0 || count < 0)
  373.                 throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  374.             if (_size - index < count)
  375.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  376.            
  377.             return new ArrayListEnumerator(this, index, count);
  378.         }
  379.        
  380.         // Returns the index of the first occurrence of a given value in a range of
  381.         // this list. The list is searched forwards from beginning to end.
  382.         // The elements of the list are compared to the given value using the
  383.         // Object.Equals method.
  384.         //
  385.         // This method uses the Array.IndexOf method to perform the
  386.         // search.
  387.         //
  388.         public virtual int IndexOf(object value)
  389.         {
  390.             return Array.IndexOf((Array)_items, value, 0, _size);
  391.         }
  392.        
  393.         // Returns the index of the first occurrence of a given value in a range of
  394.         // this list. The list is searched forwards, starting at index
  395.         // startIndex and ending at count number of elements. The
  396.         // elements of the list are compared to the given value using the
  397.         // Object.Equals method.
  398.         //
  399.         // This method uses the Array.IndexOf method to perform the
  400.         // search.
  401.         //
  402.         public virtual int IndexOf(object value, int startIndex)
  403.         {
  404.             if (startIndex > _size)
  405.                 throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  406.             return Array.IndexOf((Array)_items, value, startIndex, _size - startIndex);
  407.         }
  408.        
  409.         // Returns the index of the first occurrence of a given value in a range of
  410.         // this list. The list is searched forwards, starting at index
  411.         // startIndex and upto count number of elements. The
  412.         // elements of the list are compared to the given value using the
  413.         // Object.Equals method.
  414.         //
  415.         // This method uses the Array.IndexOf method to perform the
  416.         // search.
  417.         //
  418.         public virtual int IndexOf(object value, int startIndex, int count)
  419.         {
  420.             if (startIndex > _size)
  421.                 throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  422.             if (count < 0 || startIndex > _size - count)
  423.                 throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Count"));
  424.             return Array.IndexOf((Array)_items, value, startIndex, count);
  425.         }
  426.        
  427.         // Inserts an element into this list at a given index. The size of the list
  428.         // is increased by one. If required, the capacity of the list is doubled
  429.         // before inserting the new element.
  430.         //
  431.         public virtual void Insert(int index, object value)
  432.         {
  433.             // Note that insertions at the end are legal.
  434.             if (index < 0 || index > _size)
  435.                 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_ArrayListInsert"));
  436.             if (_size == _items.Length)
  437.                 EnsureCapacity(_size + 1);
  438.             if (index < _size) {
  439.                 Array.Copy(_items, index, _items, index + 1, _size - index);
  440.             }
  441.             _items[index] = value;
  442.             _size++;
  443.             _version++;
  444.         }
  445.        
  446.         // Inserts the elements of the given collection at a given index. If
  447.         // required, the capacity of the list is increased to twice the previous
  448.         // capacity or the new size, whichever is larger. Ranges may be added
  449.         // to the end of the list by setting index to the ArrayList's size.
  450.         //
  451.         public virtual void InsertRange(int index, ICollection c)
  452.         {
  453.             if (c == null)
  454.                 throw new ArgumentNullException("c", Environment.GetResourceString("ArgumentNull_Collection"));
  455.             if (index < 0 || index > _size)
  456.                 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  457.             int count = c.Count;
  458.             if (count > 0) {
  459.                 EnsureCapacity(_size + count);
  460.                 // shift existing items
  461.                 if (index < _size) {
  462.                     Array.Copy(_items, index, _items, index + count, _size - index);
  463.                 }
  464.                
  465.                 object[] itemsToInsert = new object[count];
  466.                 c.CopyTo(itemsToInsert, 0);
  467.                 itemsToInsert.CopyTo(_items, index);
  468.                 _size += count;
  469.                 _version++;
  470.             }
  471.         }
  472.        
  473.         // Returns the index of the last occurrence of a given value in a range of
  474.         // this list. The list is searched backwards, starting at the end
  475.         // and ending at the first element in the list. The elements of the list
  476.         // are compared to the given value using the Object.Equals method.
  477.         //
  478.         // This method uses the Array.LastIndexOf method to perform the
  479.         // search.
  480.         //
  481.         public virtual int LastIndexOf(object value)
  482.         {
  483.             return LastIndexOf(value, _size - 1, _size);
  484.         }
  485.        
  486.         // Returns the index of the last occurrence of a given value in a range of
  487.         // this list. The list is searched backwards, starting at index
  488.         // startIndex and ending at the first element in the list. The
  489.         // elements of the list are compared to the given value using the
  490.         // Object.Equals method.
  491.         //
  492.         // This method uses the Array.LastIndexOf method to perform the
  493.         // search.
  494.         //
  495.         public virtual int LastIndexOf(object value, int startIndex)
  496.         {
  497.             if (startIndex >= _size)
  498.                 throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  499.             return LastIndexOf(value, startIndex, startIndex + 1);
  500.         }
  501.        
  502.         // Returns the index of the last occurrence of a given value in a range of
  503.         // this list. The list is searched backwards, starting at index
  504.         // startIndex and upto count elements. The elements of
  505.         // the list are compared to the given value using the Object.Equals
  506.         // method.
  507.         //
  508.         // This method uses the Array.LastIndexOf method to perform the
  509.         // search.
  510.         //
  511.         public virtual int LastIndexOf(object value, int startIndex, int count)
  512.         {
  513.             if (_size == 0)
  514.                 return -1;
  515.             if (startIndex < 0 || count < 0)
  516.                 throw new ArgumentOutOfRangeException((startIndex < 0 ? "startIndex" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  517.             if (startIndex >= _size || count > startIndex + 1)
  518.                 throw new ArgumentOutOfRangeException((startIndex >= _size ? "startIndex" : "count"), Environment.GetResourceString("ArgumentOutOfRange_BiggerThanCollection"));
  519.             return Array.LastIndexOf((Array)_items, value, startIndex, count);
  520.         }
  521.        
  522.         // Returns a read-only IList wrapper for the given IList.
  523.         //
  524.         public static IList ReadOnly(IList list)
  525.         {
  526.             if (list == null)
  527.                 throw new ArgumentNullException("list");
  528.             return new ReadOnlyList(list);
  529.         }
  530.        
  531.         // Returns a read-only ArrayList wrapper for the given ArrayList.
  532.         //
  533.         public static ArrayList ReadOnly(ArrayList list)
  534.         {
  535.             if (list == null)
  536.                 throw new ArgumentNullException("list");
  537.             return new ReadOnlyArrayList(list);
  538.         }
  539.        
  540.         // Removes the element at the given index. The size of the list is
  541.         // decreased by one.
  542.         //
  543.         public virtual void Remove(object obj)
  544.         {
  545.             int index = IndexOf(obj);
  546.             BCLDebug.Correctness(index >= 0 || !(obj is Int32), "You passed an Int32 to Remove that wasn't in the ArrayList.\r\nDid you mean RemoveAt? int: " + obj + " Count: " + Count);
  547.             if (index >= 0)
  548.                 RemoveAt(index);
  549.         }
  550.        
  551.         // Removes the element at the given index. The size of the list is
  552.         // decreased by one.
  553.         //
  554.         public virtual void RemoveAt(int index)
  555.         {
  556.             if (index < 0 || index >= _size)
  557.                 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  558.             _size--;
  559.             if (index < _size) {
  560.                 Array.Copy(_items, index + 1, _items, index, _size - index);
  561.             }
  562.             _items[_size] = null;
  563.             _version++;
  564.         }
  565.        
  566.         // Removes a range of elements from this list.
  567.         //
  568.         public virtual void RemoveRange(int index, int count)
  569.         {
  570.             if (index < 0 || count < 0)
  571.                 throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  572.             if (_size - index < count)
  573.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  574.            
  575.             if (count > 0) {
  576.                 int i = _size;
  577.                 _size -= count;
  578.                 if (index < _size) {
  579.                     Array.Copy(_items, index + count, _items, index, _size - index);
  580.                 }
  581.                 while (i > _size)
  582.                     _items[--i] = null;
  583.                 _version++;
  584.             }
  585.         }
  586.        
  587.         // Returns an IList that contains count copies of value.
  588.         //
  589.         public static ArrayList Repeat(object value, int count)
  590.         {
  591.             if (count < 0)
  592.                 throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  593.            
  594.             ArrayList list = new ArrayList((count > _defaultCapacity) ? count : _defaultCapacity);
  595.             for (int i = 0; i < count; i++)
  596.                 list.Add(value);
  597.             return list;
  598.         }
  599.        
  600.         // Reverses the elements in this list.
  601.         public virtual void Reverse()
  602.         {
  603.             Reverse(0, Count);
  604.         }
  605.        
  606.         // Reverses the elements in a range of this list. Following a call to this
  607.         // method, an element in the range given by index and count
  608.         // which was previously located at index i will now be located at
  609.         // index index + (index + count - i - 1).
  610.         //
  611.         // This method uses the Array.Reverse method to reverse the
  612.         // elements.
  613.         //
  614.         public virtual void Reverse(int index, int count)
  615.         {
  616.             if (index < 0 || count < 0)
  617.                 throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  618.             if (_size - index < count)
  619.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  620.             Array.Reverse(_items, index, count);
  621.             _version++;
  622.         }
  623.        
  624.         // Sets the elements starting at the given index to the elements of the
  625.         // given collection.
  626.         //
  627.         public virtual void SetRange(int index, ICollection c)
  628.         {
  629.             if (c == null)
  630.                 throw new ArgumentNullException("c", Environment.GetResourceString("ArgumentNull_Collection"));
  631.             int count = c.Count;
  632.             if (index < 0 || index > _size - count)
  633.                 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  634.            
  635.             if (count > 0) {
  636.                 c.CopyTo(_items, index);
  637.                 _version++;
  638.             }
  639.         }
  640.        
  641.         public virtual ArrayList GetRange(int index, int count)
  642.         {
  643.             if (index < 0 || count < 0)
  644.                 throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  645.             if (_size - index < count)
  646.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  647.             return new Range(this, index, count);
  648.         }
  649.        
  650.         // Sorts the elements in this list. Uses the default comparer and
  651.         // Array.Sort.
  652.         public virtual void Sort()
  653.         {
  654.             Sort(0, Count, Comparer.Default);
  655.         }
  656.        
  657.         // Sorts the elements in this list. Uses Array.Sort with the
  658.         // provided comparer.
  659.         public virtual void Sort(IComparer comparer)
  660.         {
  661.             Sort(0, Count, comparer);
  662.         }
  663.        
  664.         // Sorts the elements in a section of this list. The sort compares the
  665.         // elements to each other using the given IComparer interface. If
  666.         // comparer is null, the elements are compared to each other using
  667.         // the IComparable interface, which in that case must be implemented by all
  668.         // elements of the list.
  669.         //
  670.         // This method uses the Array.Sort method to sort the elements.
  671.         //
  672.         public virtual void Sort(int index, int count, IComparer comparer)
  673.         {
  674.             if (index < 0 || count < 0)
  675.                 throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  676.             if (_size - index < count)
  677.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  678.            
  679.             Array.Sort(_items, index, count, comparer);
  680.             _version++;
  681.         }
  682.        
  683.         // Returns a thread-safe wrapper around an IList.
  684.         //
  685.         [HostProtection(Synchronization = true)]
  686.         public static IList Synchronized(IList list)
  687.         {
  688.             if (list == null)
  689.                 throw new ArgumentNullException("list");
  690.             return new SyncIList(list);
  691.         }
  692.        
  693.         // Returns a thread-safe wrapper around a ArrayList.
  694.         //
  695.         [HostProtection(Synchronization = true)]
  696.         public static ArrayList Synchronized(ArrayList list)
  697.         {
  698.             if (list == null)
  699.                 throw new ArgumentNullException("list");
  700.             return new SyncArrayList(list);
  701.         }
  702.        
  703.         // ToArray returns a new Object array containing the contents of the ArrayList.
  704.         // This requires copying the ArrayList, which is an O(n) operation.
  705.         public virtual object[] ToArray()
  706.         {
  707.             object[] array = new object[_size];
  708.             Array.Copy(_items, 0, array, 0, _size);
  709.             return array;
  710.         }
  711.        
  712.         // ToArray returns a new array of a particular type containing the contents
  713.         // of the ArrayList. This requires copying the ArrayList and potentially
  714.         // downcasting all elements. This copy may fail and is an O(n) operation.
  715.         // Internally, this implementation calls Array.Copy.
  716.         //
  717.         public virtual Array ToArray(Type type)
  718.         {
  719.             if (type == null)
  720.                 throw new ArgumentNullException("type");
  721.             Array array = Array.CreateInstance(type, _size);
  722.             Array.Copy(_items, 0, array, 0, _size);
  723.             return array;
  724.         }
  725.        
  726.         // Sets the capacity of this list to the size of the list. This method can
  727.         // be used to minimize a list's memory overhead once it is known that no
  728.         // new elements will be added to the list. To completely clear a list and
  729.         // release all memory referenced by the list, execute the following
  730.         // statements:
  731.         //
  732.         // list.Clear();
  733.         // list.TrimToSize();
  734.         //
  735.         public virtual void TrimToSize()
  736.         {
  737.             Capacity = _size;
  738.         }
  739.        
  740.        
  741.         // This class wraps an IList, exposing it as a ArrayList
  742.         // Note this requires reimplementing half of ArrayList...
  743.         [Serializable()]
  744.         private class IListWrapper : ArrayList
  745.         {
  746.             private IList _list;
  747.            
  748.             internal IListWrapper(IList list)
  749.             {
  750.                 _list = list;
  751.                 _version = 0;
  752.                 // list doesn't not contain a version number
  753.             }
  754.            
  755.             public override int Capacity {
  756.                 get { return _list.Count; }
  757.                 set {
  758.                     if (value < _list.Count)
  759.                         throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
  760.                 }
  761.             }
  762.            
  763.             public override int Count {
  764.                 get { return _list.Count; }
  765.             }
  766.            
  767.             public override bool IsReadOnly {
  768.                 get { return _list.IsReadOnly; }
  769.             }
  770.            
  771.             public override bool IsFixedSize {
  772.                 get { return _list.IsFixedSize; }
  773.             }
  774.            
  775.            
  776.             public override bool IsSynchronized {
  777.                 get { return _list.IsSynchronized; }
  778.             }
  779.            
  780.             public override object this[int index]
  781.             {
  782.                 get { return _list[index]; }
  783.                 set {
  784.                     _list[index] = value;
  785.                     _version++;
  786.                 }
  787.             }
  788.            
  789.             public override object SyncRoot {
  790.                 get { return _list.SyncRoot; }
  791.             }
  792.            
  793.             public override int Add(object obj)
  794.             {
  795.                 int i = _list.Add(obj);
  796.                 _version++;
  797.                 return i;
  798.             }
  799.            
  800.             public override void AddRange(ICollection c)
  801.             {
  802.                 InsertRange(Count, c);
  803.             }
  804.            
  805.             // Other overloads with automatically work
  806.             public override int BinarySearch(int index, int count, object value, IComparer comparer)
  807.             {
  808.                 if (index < 0 || count < 0)
  809.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  810.                 if (_list.Count - index < count)
  811.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  812.                 if (comparer == null)
  813.                     comparer = Comparer.Default;
  814.                
  815.                 int lo = index;
  816.                 int hi = index + count - 1;
  817.                 int mid;
  818.                 while (lo <= hi) {
  819.                     mid = (lo + hi) / 2;
  820.                     int r = comparer.Compare(value, _list[mid]);
  821.                     if (r == 0)
  822.                         return mid;
  823.                     if (r < 0)
  824.                         hi = mid - 1;
  825.                     else
  826.                         lo = mid + 1;
  827.                 }
  828.                 // return bitwise complement of the first element greater than value.
  829.                 // Since hi is less than lo now, ~lo is the correct item.
  830.                 return ~lo;
  831.             }
  832.            
  833.             public override void Clear()
  834.             {
  835.                 // If _list is an array, it will support Clear method.
  836.                 // We shouldn't allow clear operation on a FixedSized ArrayList
  837.                 if (_list.IsFixedSize) {
  838.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  839.                 }
  840.                
  841.                 _list.Clear();
  842.                 _version++;
  843.             }
  844.            
  845.             public override object Clone()
  846.             {
  847.                 // This does not do a shallow copy of _list into a ArrayList!
  848.                 // This clones the IListWrapper, creating another wrapper class!
  849.                 return new IListWrapper(_list);
  850.             }
  851.            
  852.             public override bool Contains(object obj)
  853.             {
  854.                 return _list.Contains(obj);
  855.             }
  856.            
  857.             public override void CopyTo(Array array, int index)
  858.             {
  859.                 _list.CopyTo(array, index);
  860.             }
  861.            
  862.             public override void CopyTo(int index, Array array, int arrayIndex, int count)
  863.             {
  864.                 if (array == null)
  865.                     throw new ArgumentNullException("array");
  866.                 if (index < 0 || arrayIndex < 0)
  867.                     throw new ArgumentOutOfRangeException((index < 0) ? "index" : "arrayIndex", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  868.                 if (count < 0)
  869.                     throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  870.                 if (array.Length - arrayIndex < count)
  871.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  872.                 if (_list.Count - index < count)
  873.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  874.                 if (array.Rank != 1)
  875.                     throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
  876.                
  877.                 for (int i = index; i < index + count; i++)
  878.                     array.SetValue(_list[i], arrayIndex++);
  879.             }
  880.            
  881.             public override IEnumerator GetEnumerator()
  882.             {
  883.                 return _list.GetEnumerator();
  884.             }
  885.            
  886.             public override IEnumerator GetEnumerator(int index, int count)
  887.             {
  888.                 if (index < 0 || count < 0)
  889.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  890.                 if (_list.Count - index < count)
  891.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  892.                
  893.                 return new IListWrapperEnumWrapper(this, index, count);
  894.             }
  895.            
  896.             public override int IndexOf(object value)
  897.             {
  898.                 return _list.IndexOf(value);
  899.             }
  900.            
  901.             public override int IndexOf(object value, int startIndex)
  902.             {
  903.                 return IndexOf(value, startIndex, _list.Count - startIndex);
  904.             }
  905.            
  906.             public override int IndexOf(object value, int startIndex, int count)
  907.             {
  908.                 if (startIndex < 0 || startIndex > _list.Count)
  909.                     throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  910.                 if (count < 0 || startIndex > _list.Count - count)
  911.                     throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Count"));
  912.                
  913.                 int endIndex = startIndex + count;
  914.                 if (value == null) {
  915.                     for (int i = startIndex; i < endIndex; i++)
  916.                         if (_list[i] == null)
  917.                             return i;
  919.                     return -1;
  920.                 }
  921.                 else {
  922.                     for (int i = startIndex; i < endIndex; i++)
  923.                         if (_list[i] != null && _list[i].Equals(value))
  924.                             return i;
  926.                     return -1;
  927.                 }
  928.             }
  929.            
  930.             public override void Insert(int index, object obj)
  931.             {
  932.                 _list.Insert(index, obj);
  933.                 _version++;
  934.             }
  935.            
  936.             public override void InsertRange(int index, ICollection c)
  937.             {
  938.                 if (c == null)
  939.                     throw new ArgumentNullException("c", Environment.GetResourceString("ArgumentNull_Collection"));
  940.                 if (index < 0 || index > _list.Count)
  941.                     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  942.                
  943.                 if (c.Count > 0) {
  944.                     ArrayList al = _list as ArrayList;
  945.                     if (al != null) {
  946.                         // We need to special case ArrayList.
  947.                         // When c is a range of _list, we need to handle this in a special way.
  948.                         // See ArrayList.InsertRange for details.
  949.                         al.InsertRange(index, c);
  950.                     }
  951.                     else {
  952.                         IEnumerator en = c.GetEnumerator();
  953.                         while (en.MoveNext()) {
  954.                             _list.Insert(index++, en.Current);
  955.                         }
  956.                     }
  957.                     _version++;
  958.                 }
  959.             }
  960.            
  961.             public override int LastIndexOf(object value)
  962.             {
  963.                 return LastIndexOf(value, _list.Count - 1, _list.Count);
  964.             }
  965.            
  966.             public override int LastIndexOf(object value, int startIndex)
  967.             {
  968.                 return LastIndexOf(value, startIndex, startIndex + 1);
  969.             }
  970.            
  971.             public override int LastIndexOf(object value, int startIndex, int count)
  972.             {
  973.                 if (_list.Count == 0)
  974.                     return -1;
  975.                
  976.                 if (startIndex < 0 || startIndex >= _list.Count)
  977.                     throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  978.                 if (count < 0 || count > startIndex + 1)
  979.                     throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Count"));
  980.                
  981.                 int endIndex = startIndex - count + 1;
  982.                 if (value == null) {
  983.                     for (int i = startIndex; i >= endIndex; i--)
  984.                         if (_list[i] == null)
  985.                             return i;
  987.                     return -1;
  988.                 }
  989.                 else {
  990.                     for (int i = startIndex; i >= endIndex; i--)
  991.                         if (_list[i] != null && _list[i].Equals(value))
  992.                             return i;
  994.                     return -1;
  995.                 }
  996.             }
  997.            
  998.             public override void Remove(object value)
  999.             {
  1000.                 int index = IndexOf(value);
  1001.                 if (index >= 0)
  1002.                     RemoveAt(index);
  1003.             }
  1004.            
  1005.             public override void RemoveAt(int index)
  1006.             {
  1007.                 _list.RemoveAt(index);
  1008.                 _version++;
  1009.             }
  1010.            
  1011.             public override void RemoveRange(int index, int count)
  1012.             {
  1013.                 if (index < 0 || count < 0)
  1014.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  1015.                 if (_list.Count - index < count)
  1016.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  1017.                
  1018.                 if (count > 0)
  1019.                     // be consistent with ArrayList
  1020.                     _version++;
  1021.                
  1022.                 while (count > 0) {
  1023.                     _list.RemoveAt(index);
  1024.                     count--;
  1025.                 }
  1026.             }
  1027.            
  1028.             public override void Reverse(int index, int count)
  1029.             {
  1030.                 if (index < 0 || count < 0)
  1031.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  1032.                 if (_list.Count - index < count)
  1033.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  1034.                
  1035.                 int i = index;
  1036.                 int j = index + count - 1;
  1037.                 while (i < j) {
  1038.                     object tmp = _list[i];
  1039.                     _list[i++] = _list[j];
  1040.                     _list[j--] = tmp;
  1041.                 }
  1042.                 _version++;
  1043.             }
  1044.            
  1045.             public override void SetRange(int index, ICollection c)
  1046.             {
  1047.                 if (c == null) {
  1048.                     throw new ArgumentNullException("c", Environment.GetResourceString("ArgumentNull_Collection"));
  1049.                 }
  1050.                
  1051.                 if (index < 0 || index > _list.Count - c.Count) {
  1052.                     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  1053.                 }
  1054.                
  1055.                 if (c.Count > 0) {
  1056.                     IEnumerator en = c.GetEnumerator();
  1057.                     while (en.MoveNext()) {
  1058.                         _list[index++] = en.Current;
  1059.                     }
  1060.                     _version++;
  1061.                 }
  1062.             }
  1063.            
  1064.             public override ArrayList GetRange(int index, int count)
  1065.             {
  1066.                 if (index < 0 || count < 0)
  1067.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  1068.                 if (_list.Count - index < count)
  1069.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  1070.                 return new Range(this, index, count);
  1071.             }
  1072.            
  1073.             public override void Sort(int index, int count, IComparer comparer)
  1074.             {
  1075.                 if (index < 0 || count < 0)
  1076.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  1077.                 if (_list.Count - index < count)
  1078.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  1079.                
  1080.                 object[] array = new object[count];
  1081.                 CopyTo(index, array, 0, count);
  1082.                 Array.Sort(array, 0, count, comparer);
  1083.                 for (int i = 0; i < count; i++)
  1084.                     _list[i + index] = array[i];
  1085.                
  1086.                 _version++;
  1087.             }
  1088.            
  1089.            
  1090.             public override object[] ToArray()
  1091.             {
  1092.                 object[] array = new object[Count];
  1093.                 _list.CopyTo(array, 0);
  1094.                 return array;
  1095.             }
  1096.            
  1097.             public override Array ToArray(Type type)
  1098.             {
  1099.                 if (type == null)
  1100.                     throw new ArgumentNullException("type");
  1101.                 Array array = Array.CreateInstance(type, _list.Count);
  1102.                 _list.CopyTo(array, 0);
  1103.                 return array;
  1104.             }
  1105.            
  1106.             public override void TrimToSize()
  1107.             {
  1108.                 // Can't really do much here...
  1109.             }
  1110.            
  1111.             // This is the enumerator for an IList that's been wrapped in another
  1112.             // class that implements all of ArrayList's methods.
  1113.             [Serializable()]
  1114.             private sealed class IListWrapperEnumWrapper : IEnumerator, ICloneable
  1115.             {
  1116.                 private IEnumerator _en;
  1117.                 private int _remaining;
  1118.                 private int _initialStartIndex;
  1119.                 // for reset
  1120.                 private int _initialCount;
  1121.                 // for reset
  1122.                 private bool _firstCall;
  1123.                 // firstCall to MoveNext
  1124.                 private IListWrapperEnumWrapper()
  1125.                 {
  1126.                 }
  1127.                
  1128.                 internal IListWrapperEnumWrapper(IListWrapper listWrapper, int startIndex, int count)
  1129.                 {
  1130.                     _en = listWrapper.GetEnumerator();
  1131.                     _initialStartIndex = startIndex;
  1132.                     _initialCount = count;
  1133.                     while (startIndex-- > 0 && _en.MoveNext())
  1134.                         ;
  1135.                     _remaining = count;
  1136.                     _firstCall = true;
  1137.                 }
  1138.                
  1139.                 public object Clone()
  1140.                 {
  1141.                     // We must clone the underlying enumerator, I think.
  1142.                     IListWrapperEnumWrapper clone = new IListWrapperEnumWrapper();
  1143.                     clone._en = (IEnumerator)((ICloneable)_en).Clone();
  1144.                     clone._initialStartIndex = _initialStartIndex;
  1145.                     clone._initialCount = _initialCount;
  1146.                     clone._remaining = _remaining;
  1147.                     clone._firstCall = _firstCall;
  1148.                     return clone;
  1149.                 }
  1150.                
  1151.                 public bool MoveNext()
  1152.                 {
  1153.                     if (_firstCall) {
  1154.                         _firstCall = false;
  1155.                         return _remaining-- > 0 && _en.MoveNext();
  1156.                     }
  1157.                     if (_remaining < 0)
  1158.                         return false;
  1159.                     bool r = _en.MoveNext();
  1160.                     return r && _remaining-- > 0;
  1161.                 }
  1162.                
  1163.                 public object Current {
  1164.                     get {
  1165.                         if (_firstCall)
  1166.                             throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
  1167.                         if (_remaining < 0)
  1168.                             throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
  1169.                         return _en.Current;
  1170.                     }
  1171.                 }
  1172.                
  1173.                 public void Reset()
  1174.                 {
  1175.                     _en.Reset();
  1176.                     int startIndex = _initialStartIndex;
  1177.                     while (startIndex-- > 0 && _en.MoveNext())
  1178.                         ;
  1179.                     _remaining = _initialCount;
  1180.                     _firstCall = true;
  1181.                 }
  1182.             }
  1183.         }
  1184.        
  1185.        
  1186.         [Serializable()]
  1187.         private class SyncArrayList : ArrayList
  1188.         {
  1189.             private ArrayList _list;
  1190.             private object _root;
  1191.            
  1192.             internal SyncArrayList(ArrayList list) : base(false)
  1193.             {
  1194.                 _list = list;
  1195.                 _root = list.SyncRoot;
  1196.             }
  1197.            
  1198.             public override int Capacity {
  1199.                 get {
  1200.                     lock (_root) {
  1201.                         return _list.Capacity;
  1202.                     }
  1203.                 }
  1204.                 set {
  1205.                     lock (_root) {
  1206.                         _list.Capacity = value;
  1207.                     }
  1208.                 }
  1209.             }
  1210.            
  1211.             public override int Count {
  1212.                 get {
  1213.                     lock (_root) {
  1214.                         return _list.Count;
  1215.                     }
  1216.                 }
  1217.             }
  1218.            
  1219.             public override bool IsReadOnly {
  1220.                 get { return _list.IsReadOnly; }
  1221.             }
  1222.            
  1223.             public override bool IsFixedSize {
  1224.                 get { return _list.IsFixedSize; }
  1225.             }
  1226.            
  1227.            
  1228.             public override bool IsSynchronized {
  1229.                 get { return true; }
  1230.             }
  1231.            
  1232.             public override object this[int index]
  1233.             {
  1234.                 get {
  1235.                     lock (_root) {
  1236.                         return _list[index];
  1237.                     }
  1238.                 }
  1239.                 set {
  1240.                     lock (_root) {
  1241.                         _list[index] = value;
  1242.                     }
  1243.                 }
  1244.             }
  1245.            
  1246.             public override object SyncRoot {
  1247.                 get { return _root; }
  1248.             }
  1249.            
  1250.             public override int Add(object value)
  1251.             {
  1252.                 lock (_root) {
  1253.                     return _list.Add(value);
  1254.                 }
  1255.             }
  1256.            
  1257.             public override void AddRange(ICollection c)
  1258.             {
  1259.                 lock (_root) {
  1260.                     _list.AddRange(c);
  1261.                 }
  1262.             }
  1263.            
  1264.             public override int BinarySearch(object value)
  1265.             {
  1266.                 lock (_root) {
  1267.                     return _list.BinarySearch(value);
  1268.                 }
  1269.             }
  1270.            
  1271.             public override int BinarySearch(object value, IComparer comparer)
  1272.             {
  1273.                 lock (_root) {
  1274.                     return _list.BinarySearch(value, comparer);
  1275.                 }
  1276.             }
  1277.            
  1278.             public override int BinarySearch(int index, int count, object value, IComparer comparer)
  1279.             {
  1280.                 lock (_root) {
  1281.                     return _list.BinarySearch(index, count, value, comparer);
  1282.                 }
  1283.             }
  1284.            
  1285.             public override void Clear()
  1286.             {
  1287.                 lock (_root) {
  1288.                     _list.Clear();
  1289.                 }
  1290.             }
  1291.            
  1292.             public override object Clone()
  1293.             {
  1294.                 lock (_root) {
  1295.                     return new SyncArrayList((ArrayList)_list.Clone());
  1296.                 }
  1297.             }
  1298.            
  1299.             public override bool Contains(object item)
  1300.             {
  1301.                 lock (_root) {
  1302.                     return _list.Contains(item);
  1303.                 }
  1304.             }
  1305.            
  1306.             public override void CopyTo(Array array)
  1307.             {
  1308.                 lock (_root) {
  1309.                     _list.CopyTo(array);
  1310.                 }
  1311.             }
  1312.            
  1313.             public override void CopyTo(Array array, int index)
  1314.             {
  1315.                 lock (_root) {
  1316.                     _list.CopyTo(array, index);
  1317.                 }
  1318.             }
  1319.            
  1320.             public override void CopyTo(int index, Array array, int arrayIndex, int count)
  1321.             {
  1322.                 lock (_root) {
  1323.                     _list.CopyTo(index, array, arrayIndex, count);
  1324.                 }
  1325.             }
  1326.            
  1327.             public override IEnumerator GetEnumerator()
  1328.             {
  1329.                 lock (_root) {
  1330.                     return _list.GetEnumerator();
  1331.                 }
  1332.             }
  1333.            
  1334.             public override IEnumerator GetEnumerator(int index, int count)
  1335.             {
  1336.                 lock (_root) {
  1337.                     return _list.GetEnumerator(index, count);
  1338.                 }
  1339.             }
  1340.            
  1341.             public override int IndexOf(object value)
  1342.             {
  1343.                 lock (_root) {
  1344.                     return _list.IndexOf(value);
  1345.                 }
  1346.             }
  1347.            
  1348.             public override int IndexOf(object value, int startIndex)
  1349.             {
  1350.                 lock (_root) {
  1351.                     return _list.IndexOf(value, startIndex);
  1352.                 }
  1353.             }
  1354.            
  1355.             public override int IndexOf(object value, int startIndex, int count)
  1356.             {
  1357.                 lock (_root) {
  1358.                     return _list.IndexOf(value, startIndex, count);
  1359.                 }
  1360.             }
  1361.            
  1362.             public override void Insert(int index, object value)
  1363.             {
  1364.                 lock (_root) {
  1365.                     _list.Insert(index, value);
  1366.                 }
  1367.             }
  1368.            
  1369.             public override void InsertRange(int index, ICollection c)
  1370.             {
  1371.                 lock (_root) {
  1372.                     _list.InsertRange(index, c);
  1373.                 }
  1374.             }
  1375.            
  1376.             public override int LastIndexOf(object value)
  1377.             {
  1378.                 lock (_root) {
  1379.                     return _list.LastIndexOf(value);
  1380.                 }
  1381.             }
  1382.            
  1383.             public override int LastIndexOf(object value, int startIndex)
  1384.             {
  1385.                 lock (_root) {
  1386.                     return _list.LastIndexOf(value, startIndex);
  1387.                 }
  1388.             }
  1389.            
  1390.             public override int LastIndexOf(object value, int startIndex, int count)
  1391.             {
  1392.                 lock (_root) {
  1393.                     return _list.LastIndexOf(value, startIndex, count);
  1394.                 }
  1395.             }
  1396.            
  1397.             public override void Remove(object value)
  1398.             {
  1399.                 lock (_root) {
  1400.                     _list.Remove(value);
  1401.                 }
  1402.             }
  1403.            
  1404.             public override void RemoveAt(int index)
  1405.             {
  1406.                 lock (_root) {
  1407.                     _list.RemoveAt(index);
  1408.                 }
  1409.             }
  1410.            
  1411.             public override void RemoveRange(int index, int count)
  1412.             {
  1413.                 lock (_root) {
  1414.                     _list.RemoveRange(index, count);
  1415.                 }
  1416.             }
  1417.            
  1418.             public override void Reverse(int index, int count)
  1419.             {
  1420.                 lock (_root) {
  1421.                     _list.Reverse(index, count);
  1422.                 }
  1423.             }
  1424.            
  1425.             public override void SetRange(int index, ICollection c)
  1426.             {
  1427.                 lock (_root) {
  1428.                     _list.SetRange(index, c);
  1429.                 }
  1430.             }
  1431.            
  1432.             public override ArrayList GetRange(int index, int count)
  1433.             {
  1434.                 lock (_root) {
  1435.                     return _list.GetRange(index, count);
  1436.                 }
  1437.             }
  1438.            
  1439.             public override void Sort()
  1440.             {
  1441.                 lock (_root) {
  1442.                     _list.Sort();
  1443.                 }
  1444.             }
  1445.            
  1446.             public override void Sort(IComparer comparer)
  1447.             {
  1448.                 lock (_root) {
  1449.                     _list.Sort(comparer);
  1450.                 }
  1451.             }
  1452.            
  1453.             public override void Sort(int index, int count, IComparer comparer)
  1454.             {
  1455.                 lock (_root) {
  1456.                     _list.Sort(index, count, comparer);
  1457.                 }
  1458.             }
  1459.            
  1460.             public override object[] ToArray()
  1461.             {
  1462.                 lock (_root) {
  1463.                     return _list.ToArray();
  1464.                 }
  1465.             }
  1466.            
  1467.             public override Array ToArray(Type type)
  1468.             {
  1469.                 lock (_root) {
  1470.                     return _list.ToArray(type);
  1471.                 }
  1472.             }
  1473.            
  1474.             public override void TrimToSize()
  1475.             {
  1476.                 lock (_root) {
  1477.                     _list.TrimToSize();
  1478.                 }
  1479.             }
  1480.         }
  1481.        
  1482.        
  1483.         [Serializable()]
  1484.         private class SyncIList : IList
  1485.         {
  1486.             private IList _list;
  1487.             private object _root;
  1488.            
  1489.             internal SyncIList(IList list)
  1490.             {
  1491.                 _list = list;
  1492.                 _root = list.SyncRoot;
  1493.             }
  1494.            
  1495.             public virtual int Count {
  1496.                 get {
  1497.                     lock (_root) {
  1498.                         return _list.Count;
  1499.                     }
  1500.                 }
  1501.             }
  1502.            
  1503.             public virtual bool IsReadOnly {
  1504.                 get { return _list.IsReadOnly; }
  1505.             }
  1506.            
  1507.             public virtual bool IsFixedSize {
  1508.                 get { return _list.IsFixedSize; }
  1509.             }
  1510.            
  1511.            
  1512.             public virtual bool IsSynchronized {
  1513.                 get { return true; }
  1514.             }
  1515.            
  1516.             public virtual object this[int index]
  1517.             {
  1518.                 get {
  1519.                     lock (_root) {
  1520.                         return _list[index];
  1521.                     }
  1522.                 }
  1523.                 set {
  1524.                     lock (_root) {
  1525.                         _list[index] = value;
  1526.                     }
  1527.                 }
  1528.             }
  1529.            
  1530.             public virtual object SyncRoot {
  1531.                 get { return _root; }
  1532.             }
  1533.            
  1534.             public virtual int Add(object value)
  1535.             {
  1536.                 lock (_root) {
  1537.                     return _list.Add(value);
  1538.                 }
  1539.             }
  1540.            
  1541.            
  1542.             public virtual void Clear()
  1543.             {
  1544.                 lock (_root) {
  1545.                     _list.Clear();
  1546.                 }
  1547.             }
  1548.            
  1549.             public virtual bool Contains(object item)
  1550.             {
  1551.                 lock (_root) {
  1552.                     return _list.Contains(item);
  1553.                 }
  1554.             }
  1555.            
  1556.             public virtual void CopyTo(Array array, int index)
  1557.             {
  1558.                 lock (_root) {
  1559.                     _list.CopyTo(array, index);
  1560.                 }
  1561.             }
  1562.            
  1563.             public virtual IEnumerator GetEnumerator()
  1564.             {
  1565.                 lock (_root) {
  1566.                     return _list.GetEnumerator();
  1567.                 }
  1568.             }
  1569.            
  1570.             public virtual int IndexOf(object value)
  1571.             {
  1572.                 lock (_root) {
  1573.                     return _list.IndexOf(value);
  1574.                 }
  1575.             }
  1576.            
  1577.             public virtual void Insert(int index, object value)
  1578.             {
  1579.                 lock (_root) {
  1580.                     _list.Insert(index, value);
  1581.                 }
  1582.             }
  1583.            
  1584.             public virtual void Remove(object value)
  1585.             {
  1586.                 lock (_root) {
  1587.                     _list.Remove(value);
  1588.                 }
  1589.             }
  1590.            
  1591.             public virtual void RemoveAt(int index)
  1592.             {
  1593.                 lock (_root) {
  1594.                     _list.RemoveAt(index);
  1595.                 }
  1596.             }
  1597.         }
  1598.        
  1599.         [Serializable()]
  1600.         private class FixedSizeList : IList
  1601.         {
  1602.             private IList _list;
  1603.            
  1604.             internal FixedSizeList(IList l)
  1605.             {
  1606.                 _list = l;
  1607.             }
  1608.            
  1609.             public virtual int Count {
  1610.                 get { return _list.Count; }
  1611.             }
  1612.            
  1613.             public virtual bool IsReadOnly {
  1614.                 get { return _list.IsReadOnly; }
  1615.             }
  1616.            
  1617.             public virtual bool IsFixedSize {
  1618.                 get { return true; }
  1619.             }
  1620.            
  1621.             public virtual bool IsSynchronized {
  1622.                 get { return _list.IsSynchronized; }
  1623.             }
  1624.            
  1625.             public virtual object this[int index]
  1626.             {
  1627.                 get { return _list[index]; }
  1628.                 set { _list[index] = value; }
  1629.             }
  1630.            
  1631.             public virtual object SyncRoot {
  1632.                 get { return _list.SyncRoot; }
  1633.             }
  1634.            
  1635.             public virtual int Add(object obj)
  1636.             {
  1637.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1638.             }
  1639.            
  1640.             public virtual void Clear()
  1641.             {
  1642.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1643.             }
  1644.            
  1645.             public virtual bool Contains(object obj)
  1646.             {
  1647.                 return _list.Contains(obj);
  1648.             }
  1649.            
  1650.             public virtual void CopyTo(Array array, int index)
  1651.             {
  1652.                 _list.CopyTo(array, index);
  1653.             }
  1654.            
  1655.             public virtual IEnumerator GetEnumerator()
  1656.             {
  1657.                 return _list.GetEnumerator();
  1658.             }
  1659.            
  1660.             public virtual int IndexOf(object value)
  1661.             {
  1662.                 return _list.IndexOf(value);
  1663.             }
  1664.            
  1665.             public virtual void Insert(int index, object obj)
  1666.             {
  1667.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1668.             }
  1669.            
  1670.             public virtual void Remove(object value)
  1671.             {
  1672.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1673.             }
  1674.            
  1675.             public virtual void RemoveAt(int index)
  1676.             {
  1677.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1678.             }
  1679.         }
  1680.        
  1681.         [Serializable()]
  1682.         private class FixedSizeArrayList : ArrayList
  1683.         {
  1684.             private ArrayList _list;
  1685.            
  1686.             internal FixedSizeArrayList(ArrayList l)
  1687.             {
  1688.                 _list = l;
  1689.                 _version = _list._version;
  1690.             }
  1691.            
  1692.             public override int Count {
  1693.                 get { return _list.Count; }
  1694.             }
  1695.            
  1696.             public override bool IsReadOnly {
  1697.                 get { return _list.IsReadOnly; }
  1698.             }
  1699.            
  1700.             public override bool IsFixedSize {
  1701.                 get { return true; }
  1702.             }
  1703.            
  1704.             public override bool IsSynchronized {
  1705.                 get { return _list.IsSynchronized; }
  1706.             }
  1707.            
  1708.             public override object this[int index]
  1709.             {
  1710.                 get { return _list[index]; }
  1711.                 set {
  1712.                     _list[index] = value;
  1713.                     _version = _list._version;
  1714.                 }
  1715.             }
  1716.            
  1717.             public override object SyncRoot {
  1718.                 get { return _list.SyncRoot; }
  1719.             }
  1720.            
  1721.             public override int Add(object obj)
  1722.             {
  1723.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1724.             }
  1725.            
  1726.             public override void AddRange(ICollection c)
  1727.             {
  1728.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1729.             }
  1730.            
  1731.             public override int BinarySearch(int index, int count, object value, IComparer comparer)
  1732.             {
  1733.                 return _list.BinarySearch(index, count, value, comparer);
  1734.             }
  1735.            
  1736.             public override int Capacity {
  1737.                 get { return _list.Capacity; }
  1738.                 set {
  1739.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1740.                 }
  1741.             }
  1742.            
  1743.             public override void Clear()
  1744.             {
  1745.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1746.             }
  1747.            
  1748.             public override object Clone()
  1749.             {
  1750.                 FixedSizeArrayList arrayList = new FixedSizeArrayList(_list);
  1751.                 arrayList._list = (ArrayList)_list.Clone();
  1752.                 return arrayList;
  1753.             }
  1754.            
  1755.             public override bool Contains(object obj)
  1756.             {
  1757.                 return _list.Contains(obj);
  1758.             }
  1759.            
  1760.             public override void CopyTo(Array array, int index)
  1761.             {
  1762.                 _list.CopyTo(array, index);
  1763.             }
  1764.            
  1765.             public override void CopyTo(int index, Array array, int arrayIndex, int count)
  1766.             {
  1767.                 _list.CopyTo(index, array, arrayIndex, count);
  1768.             }
  1769.            
  1770.             public override IEnumerator GetEnumerator()
  1771.             {
  1772.                 return _list.GetEnumerator();
  1773.             }
  1774.            
  1775.             public override IEnumerator GetEnumerator(int index, int count)
  1776.             {
  1777.                 return _list.GetEnumerator(index, count);
  1778.             }
  1779.            
  1780.             public override int IndexOf(object value)
  1781.             {
  1782.                 return _list.IndexOf(value);
  1783.             }
  1784.            
  1785.             public override int IndexOf(object value, int startIndex)
  1786.             {
  1787.                 return _list.IndexOf(value, startIndex);
  1788.             }
  1789.            
  1790.             public override int IndexOf(object value, int startIndex, int count)
  1791.             {
  1792.                 return _list.IndexOf(value, startIndex, count);
  1793.             }
  1794.            
  1795.             public override void Insert(int index, object obj)
  1796.             {
  1797.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1798.             }
  1799.            
  1800.             public override void InsertRange(int index, ICollection c)
  1801.             {
  1802.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1803.             }
  1804.            
  1805.             public override int LastIndexOf(object value)
  1806.             {
  1807.                 return _list.LastIndexOf(value);
  1808.             }
  1809.            
  1810.             public override int LastIndexOf(object value, int startIndex)
  1811.             {
  1812.                 return _list.LastIndexOf(value, startIndex);
  1813.             }
  1814.            
  1815.             public override int LastIndexOf(object value, int startIndex, int count)
  1816.             {
  1817.                 return _list.LastIndexOf(value, startIndex, count);
  1818.             }
  1819.            
  1820.             public override void Remove(object value)
  1821.             {
  1822.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1823.             }
  1824.            
  1825.             public override void RemoveAt(int index)
  1826.             {
  1827.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1828.             }
  1829.            
  1830.             public override void RemoveRange(int index, int count)
  1831.             {
  1832.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1833.             }
  1834.            
  1835.             public override void SetRange(int index, ICollection c)
  1836.             {
  1837.                 _list.SetRange(index, c);
  1838.                 _version = _list._version;
  1839.             }
  1840.            
  1841.             public override ArrayList GetRange(int index, int count)
  1842.             {
  1843.                 if (index < 0 || count < 0)
  1844.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  1845.                 if (Count - index < count)
  1846.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  1847.                 return new Range(this, index, count);
  1848.             }
  1849.            
  1850.             public override void Reverse(int index, int count)
  1851.             {
  1852.                 _list.Reverse(index, count);
  1853.                 _version = _list._version;
  1854.             }
  1855.            
  1856.             public override void Sort(int index, int count, IComparer comparer)
  1857.             {
  1858.                 _list.Sort(index, count, comparer);
  1859.                 _version = _list._version;
  1860.             }
  1861.            
  1862.             public override object[] ToArray()
  1863.             {
  1864.                 return _list.ToArray();
  1865.             }
  1866.            
  1867.             public override Array ToArray(Type type)
  1868.             {
  1869.                 return _list.ToArray(type);
  1870.             }
  1871.            
  1872.             public override void TrimToSize()
  1873.             {
  1874.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
  1875.             }
  1876.         }
  1877.        
  1878.         [Serializable()]
  1879.         private class ReadOnlyList : IList
  1880.         {
  1881.             private IList _list;
  1882.            
  1883.             internal ReadOnlyList(IList l)
  1884.             {
  1885.                 _list = l;
  1886.             }
  1887.            
  1888.             public virtual int Count {
  1889.                 get { return _list.Count; }
  1890.             }
  1891.            
  1892.             public virtual bool IsReadOnly {
  1893.                 get { return true; }
  1894.             }
  1895.            
  1896.             public virtual bool IsFixedSize {
  1897.                 get { return true; }
  1898.             }
  1899.            
  1900.             public virtual bool IsSynchronized {
  1901.                 get { return _list.IsSynchronized; }
  1902.             }
  1903.            
  1904.             public virtual object this[int index]
  1905.             {
  1906.                 get { return _list[index]; }
  1907.                 set {
  1908.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  1909.                 }
  1910.             }
  1911.            
  1912.             public virtual object SyncRoot {
  1913.                 get { return _list.SyncRoot; }
  1914.             }
  1915.            
  1916.             public virtual int Add(object obj)
  1917.             {
  1918.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  1919.             }
  1920.            
  1921.             public virtual void Clear()
  1922.             {
  1923.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  1924.             }
  1925.            
  1926.             public virtual bool Contains(object obj)
  1927.             {
  1928.                 return _list.Contains(obj);
  1929.             }
  1930.            
  1931.             public virtual void CopyTo(Array array, int index)
  1932.             {
  1933.                 _list.CopyTo(array, index);
  1934.             }
  1935.            
  1936.             public virtual IEnumerator GetEnumerator()
  1937.             {
  1938.                 return _list.GetEnumerator();
  1939.             }
  1940.            
  1941.             public virtual int IndexOf(object value)
  1942.             {
  1943.                 return _list.IndexOf(value);
  1944.             }
  1945.            
  1946.             public virtual void Insert(int index, object obj)
  1947.             {
  1948.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  1949.             }
  1950.            
  1951.             public virtual void Remove(object value)
  1952.             {
  1953.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  1954.             }
  1955.            
  1956.             public virtual void RemoveAt(int index)
  1957.             {
  1958.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  1959.             }
  1960.         }
  1961.        
  1962.         [Serializable()]
  1963.         private class ReadOnlyArrayList : ArrayList
  1964.         {
  1965.             private ArrayList _list;
  1966.            
  1967.             internal ReadOnlyArrayList(ArrayList l)
  1968.             {
  1969.                 _list = l;
  1970.             }
  1971.            
  1972.             public override int Count {
  1973.                 get { return _list.Count; }
  1974.             }
  1975.            
  1976.             public override bool IsReadOnly {
  1977.                 get { return true; }
  1978.             }
  1979.            
  1980.             public override bool IsFixedSize {
  1981.                 get { return true; }
  1982.             }
  1983.            
  1984.             public override bool IsSynchronized {
  1985.                 get { return _list.IsSynchronized; }
  1986.             }
  1987.            
  1988.             public override object this[int index]
  1989.             {
  1990.                 get { return _list[index]; }
  1991.                 set {
  1992.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  1993.                 }
  1994.             }
  1995.            
  1996.             public override object SyncRoot {
  1997.                 get { return _list.SyncRoot; }
  1998.             }
  1999.            
  2000.             public override int Add(object obj)
  2001.             {
  2002.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2003.             }
  2004.            
  2005.             public override void AddRange(ICollection c)
  2006.             {
  2007.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2008.             }
  2009.            
  2010.             public override int BinarySearch(int index, int count, object value, IComparer comparer)
  2011.             {
  2012.                 return _list.BinarySearch(index, count, value, comparer);
  2013.             }
  2014.            
  2015.            
  2016.             public override int Capacity {
  2017.                 get { return _list.Capacity; }
  2018.                 set {
  2019.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2020.                 }
  2021.             }
  2022.            
  2023.             public override void Clear()
  2024.             {
  2025.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2026.             }
  2027.            
  2028.             public override object Clone()
  2029.             {
  2030.                 ReadOnlyArrayList arrayList = new ReadOnlyArrayList(_list);
  2031.                 arrayList._list = (ArrayList)_list.Clone();
  2032.                 return arrayList;
  2033.             }
  2034.            
  2035.             public override bool Contains(object obj)
  2036.             {
  2037.                 return _list.Contains(obj);
  2038.             }
  2039.            
  2040.             public override void CopyTo(Array array, int index)
  2041.             {
  2042.                 _list.CopyTo(array, index);
  2043.             }
  2044.            
  2045.             public override void CopyTo(int index, Array array, int arrayIndex, int count)
  2046.             {
  2047.                 _list.CopyTo(index, array, arrayIndex, count);
  2048.             }
  2049.            
  2050.             public override IEnumerator GetEnumerator()
  2051.             {
  2052.                 return _list.GetEnumerator();
  2053.             }
  2054.            
  2055.             public override IEnumerator GetEnumerator(int index, int count)
  2056.             {
  2057.                 return _list.GetEnumerator(index, count);
  2058.             }
  2059.            
  2060.             public override int IndexOf(object value)
  2061.             {
  2062.                 return _list.IndexOf(value);
  2063.             }
  2064.            
  2065.             public override int IndexOf(object value, int startIndex)
  2066.             {
  2067.                 return _list.IndexOf(value, startIndex);
  2068.             }
  2069.            
  2070.             public override int IndexOf(object value, int startIndex, int count)
  2071.             {
  2072.                 return _list.IndexOf(value, startIndex, count);
  2073.             }
  2074.            
  2075.             public override void Insert(int index, object obj)
  2076.             {
  2077.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2078.             }
  2079.            
  2080.             public override void InsertRange(int index, ICollection c)
  2081.             {
  2082.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2083.             }
  2084.            
  2085.             public override int LastIndexOf(object value)
  2086.             {
  2087.                 return _list.LastIndexOf(value);
  2088.             }
  2089.            
  2090.             public override int LastIndexOf(object value, int startIndex)
  2091.             {
  2092.                 return _list.LastIndexOf(value, startIndex);
  2093.             }
  2094.            
  2095.             public override int LastIndexOf(object value, int startIndex, int count)
  2096.             {
  2097.                 return _list.LastIndexOf(value, startIndex, count);
  2098.             }
  2099.            
  2100.             public override void Remove(object value)
  2101.             {
  2102.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2103.             }
  2104.            
  2105.             public override void RemoveAt(int index)
  2106.             {
  2107.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2108.             }
  2109.            
  2110.             public override void RemoveRange(int index, int count)
  2111.             {
  2112.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2113.             }
  2114.            
  2115.             public override void SetRange(int index, ICollection c)
  2116.             {
  2117.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2118.             }
  2119.            
  2120.             public override ArrayList GetRange(int index, int count)
  2121.             {
  2122.                 if (index < 0 || count < 0)
  2123.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2124.                 if (Count - index < count)
  2125.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2126.                 return new Range(this, index, count);
  2127.             }
  2128.            
  2129.             public override void Reverse(int index, int count)
  2130.             {
  2131.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2132.             }
  2133.            
  2134.             public override void Sort(int index, int count, IComparer comparer)
  2135.             {
  2136.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2137.             }
  2138.            
  2139.             public override object[] ToArray()
  2140.             {
  2141.                 return _list.ToArray();
  2142.             }
  2143.            
  2144.             public override Array ToArray(Type type)
  2145.             {
  2146.                 return _list.ToArray(type);
  2147.             }
  2148.            
  2149.             public override void TrimToSize()
  2150.             {
  2151.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
  2152.             }
  2153.         }
  2154.        
  2155.        
  2156.         // Implements an enumerator for a ArrayList. The enumerator uses the
  2157.         // internal version number of the list to ensure that no modifications are
  2158.         // made to the list while an enumeration is in progress.
  2159.         [Serializable()]
  2160.         private sealed class ArrayListEnumerator : IEnumerator, ICloneable
  2161.         {
  2162.             private ArrayList list;
  2163.             private int index;
  2164.             private int endIndex;
  2165.             // Where to stop.
  2166.             private int version;
  2167.             private object currentElement;
  2168.             private int startIndex;
  2169.             // Save this for Reset.
  2170.             internal ArrayListEnumerator(ArrayList list, int index, int count)
  2171.             {
  2172.                 this.list = list;
  2173.                 startIndex = index;
  2174.                 this.index = index - 1;
  2175.                 endIndex = this.index + count;
  2176.                 // last valid index
  2177.                 version = list._version;
  2178.                 currentElement = null;
  2179.             }
  2180.            
  2181.             public object Clone()
  2182.             {
  2183.                 return MemberwiseClone();
  2184.             }
  2185.            
  2186.             public bool MoveNext()
  2187.             {
  2188.                 if (version != list._version)
  2189.                     throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
  2190.                 if (index < endIndex) {
  2191.                     currentElement = list[++index];
  2192.                     return true;
  2193.                 }
  2194.                 else {
  2195.                     index = endIndex + 1;
  2196.                 }
  2197.                
  2198.                 return false;
  2199.             }
  2200.            
  2201.             public object Current {
  2202.                 get {
  2203.                     if (index < startIndex)
  2204.                         throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
  2205.                     else if (index > endIndex) {
  2206.                         throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
  2207.                     }
  2208.                     return currentElement;
  2209.                 }
  2210.             }
  2211.            
  2212.             public void Reset()
  2213.             {
  2214.                 if (version != list._version)
  2215.                     throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
  2216.                 index = startIndex - 1;
  2217.             }
  2218.         }
  2219.        
  2220.         // Implementation of a generic list subrange. An instance of this class
  2221.         // is returned by the default implementation of List.GetRange.
  2222.         [Serializable()]
  2223.         private class Range : ArrayList
  2224.         {
  2225.             private ArrayList _baseList;
  2226.             private int _baseIndex;
  2227.             private int _baseSize;
  2228.             private int _baseVersion;
  2229.            
  2230.             internal Range(ArrayList list, int index, int count) : base(false)
  2231.             {
  2232.                 _baseList = list;
  2233.                 _baseIndex = index;
  2234.                 _baseSize = count;
  2235.                 _baseVersion = list._version;
  2236.                 // we also need to update _version field to make Range of Range work
  2237.                 _version = list._version;
  2238.             }
  2239.            
  2240.             private void InternalUpdateRange()
  2241.             {
  2242.                 if (_baseVersion != _baseList._version)
  2243.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnderlyingArrayListChanged"));
  2244.             }
  2245.            
  2246.             private void InternalUpdateVersion()
  2247.             {
  2248.                 _baseVersion++;
  2249.                 _version++;
  2250.             }
  2251.            
  2252.             public override int Add(object value)
  2253.             {
  2254.                 InternalUpdateRange();
  2255.                 _baseList.Insert(_baseIndex + _baseSize, value);
  2256.                 InternalUpdateVersion();
  2257.                 return _baseSize++;
  2258.             }
  2259.            
  2260.             public override void AddRange(ICollection c)
  2261.             {
  2262.                 InternalUpdateRange();
  2263.                 if (c == null) {
  2264.                     throw new ArgumentNullException("c");
  2265.                 }
  2266.                
  2267.                 int count = c.Count;
  2268.                 if (count > 0) {
  2269.                     _baseList.InsertRange(_baseIndex + _baseSize, c);
  2270.                     InternalUpdateVersion();
  2271.                     _baseSize += count;
  2272.                 }
  2273.             }
  2274.            
  2275.             // Other overloads with automatically work
  2276.             public override int BinarySearch(int index, int count, object value, IComparer comparer)
  2277.             {
  2278.                 InternalUpdateRange();
  2279.                 if (index < 0 || count < 0)
  2280.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2281.                 if (_baseSize - index < count)
  2282.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2283.                 int i = _baseList.BinarySearch(_baseIndex + index, count, value, comparer);
  2284.                 if (i >= 0)
  2285.                     return i - _baseIndex;
  2286.                 return i + _baseIndex;
  2287.             }
  2288.            
  2289.             public override int Capacity {
  2290.                 get { return _baseList.Capacity; }
  2291.                
  2292.                 set {
  2293.                     if (value < Count)
  2294.                         throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
  2295.                 }
  2296.             }
  2297.            
  2298.            
  2299.             public override void Clear()
  2300.             {
  2301.                 InternalUpdateRange();
  2302.                 if (_baseSize != 0) {
  2303.                     _baseList.RemoveRange(_baseIndex, _baseSize);
  2304.                     InternalUpdateVersion();
  2305.                     _baseSize = 0;
  2306.                 }
  2307.             }
  2308.            
  2309.             public override object Clone()
  2310.             {
  2311.                 InternalUpdateRange();
  2312.                 Range arrayList = new Range(_baseList, _baseIndex, _baseSize);
  2313.                 arrayList._baseList = (ArrayList)_baseList.Clone();
  2314.                 return arrayList;
  2315.             }
  2316.            
  2317.             public override bool Contains(object item)
  2318.             {
  2319.                 InternalUpdateRange();
  2320.                 if (item == null) {
  2321.                     for (int i = 0; i < _baseSize; i++)
  2322.                         if (_baseList[_baseIndex + i] == null)
  2323.                             return true;
  2325.                     return false;
  2326.                 }
  2327.                 else {
  2328.                     for (int i = 0; i < _baseSize; i++)
  2329.                         if (_baseList[_baseIndex + i] != null && _baseList[_baseIndex + i].Equals(item))
  2330.                             return true;
  2332.                     return false;
  2333.                 }
  2334.             }
  2335.            
  2336.             public override void CopyTo(Array array, int index)
  2337.             {
  2338.                 InternalUpdateRange();
  2339.                 if (array == null)
  2340.                     throw new ArgumentNullException("array");
  2341.                 if (array.Rank != 1)
  2342.                     throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
  2343.                 if (index < 0)
  2344.                     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2345.                 if (array.Length - index < _baseSize)
  2346.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2347.                 _baseList.CopyTo(_baseIndex, array, index, _baseSize);
  2348.             }
  2349.            
  2350.             public override void CopyTo(int index, Array array, int arrayIndex, int count)
  2351.             {
  2352.                 InternalUpdateRange();
  2353.                 if (array == null)
  2354.                     throw new ArgumentNullException("array");
  2355.                 if (array.Rank != 1)
  2356.                     throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
  2357.                 if (index < 0 || count < 0)
  2358.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2359.                 if (array.Length - arrayIndex < count)
  2360.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2361.                 if (_baseSize - index < count)
  2362.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2363.                 _baseList.CopyTo(_baseIndex + index, array, arrayIndex, count);
  2364.             }
  2365.            
  2366.             public override int Count {
  2367.                 get {
  2368.                     InternalUpdateRange();
  2369.                     return _baseSize;
  2370.                 }
  2371.             }
  2372.            
  2373.             public override bool IsReadOnly {
  2374.                 get { return _baseList.IsReadOnly; }
  2375.             }
  2376.            
  2377.             public override bool IsFixedSize {
  2378.                 get { return _baseList.IsFixedSize; }
  2379.             }
  2380.            
  2381.             public override bool IsSynchronized {
  2382.                 get { return _baseList.IsSynchronized; }
  2383.             }
  2384.            
  2385.             public override IEnumerator GetEnumerator()
  2386.             {
  2387.                 return GetEnumerator(0, _baseSize);
  2388.             }
  2389.            
  2390.             public override IEnumerator GetEnumerator(int index, int count)
  2391.             {
  2392.                 InternalUpdateRange();
  2393.                 if (index < 0 || count < 0)
  2394.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2395.                 if (_baseSize - index < count)
  2396.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2397.                 return _baseList.GetEnumerator(_baseIndex + index, count);
  2398.             }
  2399.            
  2400.             public override ArrayList GetRange(int index, int count)
  2401.             {
  2402.                 InternalUpdateRange();
  2403.                 if (index < 0 || count < 0)
  2404.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2405.                 if (_baseSize - index < count)
  2406.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2407.                 return new Range(this, index, count);
  2408.             }
  2409.            
  2410.             public override object SyncRoot {
  2411.                 get { return _baseList.SyncRoot; }
  2412.             }
  2413.            
  2414.            
  2415.             public override int IndexOf(object value)
  2416.             {
  2417.                 InternalUpdateRange();
  2418.                 int i = _baseList.IndexOf(value, _baseIndex, _baseSize);
  2419.                 if (i >= 0)
  2420.                     return i - _baseIndex;
  2421.                 return -1;
  2422.             }
  2423.            
  2424.             public override int IndexOf(object value, int startIndex)
  2425.             {
  2426.                 InternalUpdateRange();
  2427.                 if (startIndex < 0)
  2428.                     throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2429.                 if (startIndex > _baseSize)
  2430.                     throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2431.                
  2432.                 int i = _baseList.IndexOf(value, _baseIndex + startIndex, _baseSize - startIndex);
  2433.                 if (i >= 0)
  2434.                     return i - _baseIndex;
  2435.                 return -1;
  2436.             }
  2437.            
  2438.             public override int IndexOf(object value, int startIndex, int count)
  2439.             {
  2440.                 InternalUpdateRange();
  2441.                 if (startIndex < 0 || startIndex > _baseSize)
  2442.                     throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2443.                
  2444.                 if (count < 0 || (startIndex > _baseSize - count))
  2445.                     throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Count"));
  2446.                
  2447.                 int i = _baseList.IndexOf(value, _baseIndex + startIndex, count);
  2448.                 if (i >= 0)
  2449.                     return i - _baseIndex;
  2450.                 return -1;
  2451.             }
  2452.            
  2453.             public override void Insert(int index, object value)
  2454.             {
  2455.                 InternalUpdateRange();
  2456.                 if (index < 0 || index > _baseSize)
  2457.                     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2458.                 _baseList.Insert(_baseIndex + index, value);
  2459.                 InternalUpdateVersion();
  2460.                 _baseSize++;
  2461.             }
  2462.            
  2463.             public override void InsertRange(int index, ICollection c)
  2464.             {
  2465.                 InternalUpdateRange();
  2466.                 if (index < 0 || index > _baseSize)
  2467.                     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2468.                
  2469.                 if (c == null) {
  2470.                     throw new ArgumentNullException("c");
  2471.                    
  2472.                 }
  2473.                 int count = c.Count;
  2474.                 if (count > 0) {
  2475.                     _baseList.InsertRange(_baseIndex + index, c);
  2476.                     _baseSize += count;
  2477.                     InternalUpdateVersion();
  2478.                 }
  2479.             }
  2480.            
  2481.             public override int LastIndexOf(object value)
  2482.             {
  2483.                 InternalUpdateRange();
  2484.                 int i = _baseList.LastIndexOf(value, _baseIndex + _baseSize - 1, _baseSize);
  2485.                 if (i >= 0)
  2486.                     return i - _baseIndex;
  2487.                 return -1;
  2488.             }
  2489.            
  2490.             public override int LastIndexOf(object value, int startIndex)
  2491.             {
  2492.                 return LastIndexOf(value, startIndex, startIndex + 1);
  2493.             }
  2494.            
  2495.             public override int LastIndexOf(object value, int startIndex, int count)
  2496.             {
  2497.                 InternalUpdateRange();
  2498.                 if (_baseSize == 0)
  2499.                     return -1;
  2500.                
  2501.                 if (startIndex >= _baseSize)
  2502.                     throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2503.                 if (startIndex < 0)
  2504.                     throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2505.                
  2506.                 int i = _baseList.LastIndexOf(value, _baseIndex + startIndex, count);
  2507.                 if (i >= 0)
  2508.                     return i - _baseIndex;
  2509.                 return -1;
  2510.             }
  2511.            
  2512.             // Don't need to override Remove
  2513.            
  2514.             public override void RemoveAt(int index)
  2515.             {
  2516.                 InternalUpdateRange();
  2517.                 if (index < 0 || index >= _baseSize)
  2518.                     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2519.                 _baseList.RemoveAt(_baseIndex + index);
  2520.                 InternalUpdateVersion();
  2521.                 _baseSize--;
  2522.             }
  2523.            
  2524.             public override void RemoveRange(int index, int count)
  2525.             {
  2526.                 InternalUpdateRange();
  2527.                 if (index < 0 || count < 0)
  2528.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2529.                 if (_baseSize - index < count)
  2530.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2531.                 // No need to call _bastList.RemoveRange if count is 0.
  2532.                 // In addition, _baseList won't change the vresion number if count is 0.
  2533.                 if (count > 0) {
  2534.                     _baseList.RemoveRange(_baseIndex + index, count);
  2535.                     InternalUpdateVersion();
  2536.                     _baseSize -= count;
  2537.                 }
  2538.             }
  2539.            
  2540.             public override void Reverse(int index, int count)
  2541.             {
  2542.                 InternalUpdateRange();
  2543.                 if (index < 0 || count < 0)
  2544.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2545.                 if (_baseSize - index < count)
  2546.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2547.                 _baseList.Reverse(_baseIndex + index, count);
  2548.                 InternalUpdateVersion();
  2549.             }
  2550.            
  2551.            
  2552.             public override void SetRange(int index, ICollection c)
  2553.             {
  2554.                 InternalUpdateRange();
  2555.                 if (index < 0 || index >= _baseSize)
  2556.                     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2557.                 _baseList.SetRange(_baseIndex + index, c);
  2558.                 if (c.Count > 0) {
  2559.                     InternalUpdateVersion();
  2560.                 }
  2561.             }
  2562.            
  2563.             public override void Sort(int index, int count, IComparer comparer)
  2564.             {
  2565.                 InternalUpdateRange();
  2566.                 if (index < 0 || count < 0)
  2567.                     throw new ArgumentOutOfRangeException((index < 0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  2568.                 if (_baseSize - index < count)
  2569.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  2570.                 _baseList.Sort(_baseIndex + index, count, comparer);
  2571.                 InternalUpdateVersion();
  2572.             }
  2573.            
  2574.             public override object this[int index]
  2575.             {
  2576.                 get {
  2577.                     InternalUpdateRange();
  2578.                     if (index < 0 || index >= _baseSize)
  2579.                         throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2580.                     return _baseList[_baseIndex + index];
  2581.                 }
  2582.                 set {
  2583.                     InternalUpdateRange();
  2584.                     if (index < 0 || index >= _baseSize)
  2585.                         throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2586.                     _baseList[_baseIndex + index] = value;
  2587.                     InternalUpdateVersion();
  2588.                 }
  2589.             }
  2590.            
  2591.             public override object[] ToArray()
  2592.             {
  2593.                 InternalUpdateRange();
  2594.                 object[] array = new object[_baseSize];
  2595.                 Array.Copy(_baseList._items, _baseIndex, array, 0, _baseSize);
  2596.                 return array;
  2597.             }
  2598.            
  2599.             public override Array ToArray(Type type)
  2600.             {
  2601.                 InternalUpdateRange();
  2602.                 if (type == null)
  2603.                     throw new ArgumentNullException("type");
  2604.                 Array array = Array.CreateInstance(type, _baseSize);
  2605.                 _baseList.CopyTo(_baseIndex, array, 0, _baseSize);
  2606.                 return array;
  2607.             }
  2608.            
  2609.             public override void TrimToSize()
  2610.             {
  2611.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_RangeCollection"));
  2612.             }
  2613.         }
  2614.        
  2615.         [Serializable()]
  2616.         private sealed class ArrayListEnumeratorSimple : IEnumerator, ICloneable
  2617.         {
  2618.             private ArrayList list;
  2619.             private int index;
  2620.             private int version;
  2621.             private object currentElement;
  2622.             [NonSerializedAttribute()]
  2623.             private bool isArrayList;
  2624.             // this object is used to indicate enumeration has not started or has terminated
  2625.             static object dummyObject = new object();
  2626.            
  2627.             internal ArrayListEnumeratorSimple(ArrayList list)
  2628.             {
  2629.                 this.list = list;
  2630.                 this.index = -1;
  2631.                 version = list._version;
  2632.                 isArrayList = (list.GetType() == typeof(ArrayList));
  2633.                 currentElement = dummyObject;
  2634.             }
  2635.            
  2636.             public object Clone()
  2637.             {
  2638.                 return MemberwiseClone();
  2639.             }
  2640.            
  2641.             public bool MoveNext()
  2642.             {
  2643.                 if (version != list._version) {
  2644.                     throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
  2645.                 }
  2646.                
  2647.                 if (isArrayList) {
  2648.                     // avoid calling virtual methods if we are operating on ArrayList to improve performance
  2649.                     if (index < list._size - 1) {
  2650.                         currentElement = list._items[++index];
  2651.                         return true;
  2652.                     }
  2653.                     else {
  2654.                         currentElement = dummyObject;
  2655.                         index = list._size;
  2656.                         return false;
  2657.                     }
  2658.                 }
  2659.                 else {
  2660.                     if (index < list.Count - 1) {
  2661.                         currentElement = list[++index];
  2662.                         return true;
  2663.                     }
  2664.                     else {
  2665.                         index = list.Count;
  2666.                         currentElement = dummyObject;
  2667.                         return false;
  2668.                     }
  2669.                 }
  2670.             }
  2671.            
  2672.             public object Current {
  2673.                 get {
  2674.                     object temp = currentElement;
  2675.                     if (dummyObject == temp) {
  2676.                         // check if enumeration has not started or has terminated
  2677.                         if (index == -1) {
  2678.                             throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
  2679.                         }
  2680.                         else {
  2681.                             throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
  2682.                         }
  2683.                     }
  2684.                    
  2685.                     return temp;
  2686.                 }
  2687.             }
  2688.            
  2689.             public void Reset()
  2690.             {
  2691.                 if (version != list._version) {
  2692.                     throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
  2693.                 }
  2694.                
  2695.                 currentElement = dummyObject;
  2696.                 index = -1;
  2697.             }
  2698.         }
  2699.        
  2700.         internal class ArrayListDebugView
  2701.         {
  2702.             private ArrayList arrayList;
  2703.            
  2704.             public ArrayListDebugView(ArrayList arrayList)
  2705.             {
  2706.                 if (arrayList == null)
  2707.                     throw new ArgumentNullException("arrayList");
  2708.                
  2709.                 this.arrayList = arrayList;
  2710.             }
  2711.            
  2712.             [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
  2713.             public object[] Items {
  2714.                 get { return arrayList.ToArray(); }
  2715.             }
  2716.         }
  2717.     }
  2718. }

Developer Fusion