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

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

Developer Fusion