1 files changed, 124 insertions, 72 deletions
diff --git a/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs b/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs
index 10c48cf76d..b484879c27 100644
--- a/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs
+++ b/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs
@@ -4,150 +4,184 @@
 
 // 
 
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime;
+
 namespace System.Collections.ObjectModel
 {
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Diagnostics;
-    using System.Runtime;
-
     [Serializable]
     [DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
-    [DebuggerDisplay("Count = {Count}")]    
-    public class ReadOnlyCollection<T>: IList<T>, IList, IReadOnlyList<T>
+    [DebuggerDisplay("Count = {Count}")]
+    public class ReadOnlyCollection<T> : IList<T>, IList, IReadOnlyList<T>
     {
-        IList<T> list;
+        private IList<T> list;
         [NonSerialized]
         private Object _syncRoot;
 
-        public ReadOnlyCollection(IList<T> list) {
-            if (list == null) {
+        public ReadOnlyCollection(IList<T> list)
+        {
+            if (list == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
             }
             this.list = list;
         }
 
-        public int Count {
+        public int Count
+        {
             get { return list.Count; }
         }
 
-        public T this[int index] {
+        public T this[int index]
+        {
             get { return list[index]; }
         }
 
-        public bool Contains(T value) {
+        public bool Contains(T value)
+        {
             return list.Contains(value);
         }
 
-        public void CopyTo(T[] array, int index) {
+        public void CopyTo(T[] array, int index)
+        {
             list.CopyTo(array, index);
         }
 
-        public IEnumerator<T> GetEnumerator() {
+        public IEnumerator<T> GetEnumerator()
+        {
             return list.GetEnumerator();
         }
 
-        public int IndexOf(T value) {
+        public int IndexOf(T value)
+        {
             return list.IndexOf(value);
         }
 
-        protected IList<T> Items { 
-            get {
+        protected IList<T> Items
+        {
+            get
+            {
                 return list;
             }
         }
 
-        bool ICollection<T>.IsReadOnly {
+        bool ICollection<T>.IsReadOnly
+        {
             get { return true; }
         }
-        
-        T IList<T>.this[int index] {
+
+        T IList<T>.this[int index]
+        {
             get { return list[index]; }
-            set { 
+            set
+            {
                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
             }
         }
 
-        void ICollection<T>.Add(T value) {
+        void ICollection<T>.Add(T value)
+        {
             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
         }
-        
-        void ICollection<T>.Clear() {
+
+        void ICollection<T>.Clear()
+        {
             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
         }
 
-        void IList<T>.Insert(int index, T value) {
+        void IList<T>.Insert(int index, T value)
+        {
             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
         }
 
-        bool ICollection<T>.Remove(T value) {
+        bool ICollection<T>.Remove(T value)
+        {
             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
             return false;
         }
 
-        void IList<T>.RemoveAt(int index) {
+        void IList<T>.RemoveAt(int index)
+        {
             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
         }
 
-        IEnumerator IEnumerable.GetEnumerator() {
+        IEnumerator IEnumerable.GetEnumerator()
+        {
             return ((IEnumerable)list).GetEnumerator();
         }
 
-        bool ICollection.IsSynchronized {
+        bool ICollection.IsSynchronized
+        {
             get { return false; }
         }
 
-        object ICollection.SyncRoot { 
-            get { 
-                if( _syncRoot == null) {
+        object ICollection.SyncRoot
+        {
+            get
+            {
+                if (_syncRoot == null)
+                {
                     ICollection c = list as ICollection;
-                    if( c != null) {
+                    if (c != null)
+                    {
                         _syncRoot = c.SyncRoot;
                     }
-                    else {
-                        System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);    
+                    else
+                    {
+                        System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);
                     }
                 }
-                return _syncRoot;                
+                return _syncRoot;
             }
         }
 
-        void ICollection.CopyTo(Array array, int index) {
-            if (array==null) {
+        void ICollection.CopyTo(Array array, int index)
+        {
+            if (array == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
             }
 
-            if (array.Rank != 1) {
-                ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);                
+            if (array.Rank != 1)
+            {
+                ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
             }
 
-            if( array.GetLowerBound(0) != 0 ) {
+            if (array.GetLowerBound(0) != 0)
+            {
                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
             }
-            
-            if (index < 0) {
+
+            if (index < 0)
+            {
                 ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
             }
 
-            if (array.Length - index < Count) {
+            if (array.Length - index < Count)
+            {
                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
             }
 
             T[] items = array as T[];
-            if (items != null) {
+            if (items != null)
+            {
                 list.CopyTo(items, index);
             }
-            else {
+            else
+            {
                 //
                 // Catch the obvious case assignment will fail.
                 // We can found all possible problems by doing the check though.
                 // For example, if the element type of the Array is derived from T,
                 // we can't figure out if we can successfully copy the element beforehand.
                 //
-                Type targetType = array.GetType().GetElementType(); 
+                Type targetType = array.GetType().GetElementType();
                 Type sourceType = typeof(T);
-                if(!(targetType.IsAssignableFrom(sourceType) || sourceType.IsAssignableFrom(targetType))) {
+                if (!(targetType.IsAssignableFrom(sourceType) || sourceType.IsAssignableFrom(targetType)))
+                {
                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
                 }
 
@@ -156,76 +190,94 @@ namespace System.Collections.ObjectModel
                 // widening of primitive types here.
                 //
                 object[] objects = array as object[];
-                if( objects == null) {
+                if (objects == null)
+                {
                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
                 }
 
                 int count = list.Count;
-                try {
-                    for (int i = 0; i < count; i++) {
+                try
+                {
+                    for (int i = 0; i < count; i++)
+                    {
                         objects[index++] = list[i];
                     }
                 }
-                catch(ArrayTypeMismatchException) {
+                catch (ArrayTypeMismatchException)
+                {
                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
                 }
             }
         }
 
-        bool IList.IsFixedSize {
+        bool IList.IsFixedSize
+        {
             get { return true; }
         }
 
-        bool IList.IsReadOnly {
+        bool IList.IsReadOnly
+        {
             get { return true; }
         }
 
-        object IList.this[int index] {
+        object IList.this[int index]
+        {
             get { return list[index]; }
-            set { 
+            set
+            {
                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
             }
         }
 
-        int IList.Add(object value) {
+        int IList.Add(object value)
+        {
             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
             return -1;
         }
 
-        void IList.Clear() {
-            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);            
+        void IList.Clear()
+        {
+            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
         }
 
-        private static bool IsCompatibleObject(object value) {
+        private static bool IsCompatibleObject(object value)
+        {
             // Non-null values are fine.  Only accept nulls if T is a class or Nullable<U>.
             // Note that default(T) is not equal to null for value types except when T is Nullable<U>. 
             return ((value is T) || (value == null && default(T) == null));
         }
 
-        bool IList.Contains(object value) {
-            if(IsCompatibleObject(value)) {            
-                return Contains((T) value);                
+        bool IList.Contains(object value)
+        {
+            if (IsCompatibleObject(value))
+            {
+                return Contains((T)value);
             }
             return false;
         }
 
-        int IList.IndexOf(object value) {
-            if(IsCompatibleObject(value)) {            
+        int IList.IndexOf(object value)
+        {
+            if (IsCompatibleObject(value))
+            {
                 return IndexOf((T)value);
             }
             return -1;
         }
 
-        void IList.Insert(int index, object value) {
+        void IList.Insert(int index, object value)
+        {
             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
         }
 
-        void IList.Remove(object value) {
-            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);            
+        void IList.Remove(object value)
+        {
+            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
         }
 
-        void IList.RemoveAt(int index) {
+        void IList.RemoveAt(int index)
+        {
             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
-        }    
+        }
     }
 }