ReadOnlyCollection.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / clr / src / BCL / System / Collections / ObjectModel / ReadOnlyCollection.cs / 1 / ReadOnlyCollection.cs
                        

                        
                            namespace System.Collections.ObjectModel 
{
    using System;
    using System.Collections;
    using System.Collections.Generic; 
    using System.Diagnostics;
 
    [Serializable()] 
    [System.Runtime.InteropServices.ComVisible(false)]
    [DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))] 
    [DebuggerDisplay("Count = {Count}")]
    public class ReadOnlyCollection: IList, IList
    {
        IList list; 
        [NonSerialized]
        private Object _syncRoot; 
 
        public ReadOnlyCollection(IList list) {
            if (list == null) { 
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
            }
            this.list = list;
        } 

        public int Count { 
            get { return list.Count; } 
        }
 
        public T this[int index] {
            get { return list[index]; }
        }
 
        public bool Contains(T value) {
            return list.Contains(value); 
        } 

        public void CopyTo(T[] array, int index) { 
            list.CopyTo(array, index);
        }

        public IEnumerator GetEnumerator() { 
            return list.GetEnumerator();
        } 
 
        public int IndexOf(T value) {
            return list.IndexOf(value); 
        }

        protected IList Items {
            get { 
                return list;
            } 
        } 

        bool ICollection.IsReadOnly { 
            get { return true; }
        }

        T IList.this[int index] { 
            get { return list[index]; }
            set { 
                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
            }
        } 

        void ICollection.Add(T value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        } 

        void ICollection.Clear() { 
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
        }
 
        void IList.Insert(int index, T value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        }
 
        bool ICollection.Remove(T value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
            return false; 
        }
 
        void IList.RemoveAt(int index) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        }
 
        IEnumerator IEnumerable.GetEnumerator() {
            return ((IEnumerable)list).GetEnumerator(); 
        } 

        bool ICollection.IsSynchronized { 
            get { return false; }
        }

        object ICollection.SyncRoot { 
            get {
                if( _syncRoot == null) { 
                    ICollection c = list as ICollection; 
                    if( c != null) {
                        _syncRoot = c.SyncRoot; 
                    }
                    else {
                        System.Threading.Interlocked.CompareExchange(ref _syncRoot, new Object(), null);
                    } 
                }
                return _syncRoot; 
            } 
        }
 
        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.GetLowerBound(0) != 0 ) {
                ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
            }
 
            if (index < 0) {
                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.arrayIndex, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum); 
            } 

            if (array.Length - index < Count) { 
                ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
            }

            T[] items = array as T[]; 
            if (items != null) {
                list.CopyTo(items, index); 
            } 
            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 sourceType = typeof(T); 
                if(!(targetType.IsAssignableFrom(sourceType) || sourceType.IsAssignableFrom(targetType))) {
                    ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType); 
                }

                //
                // We can't cast array of value type to object[], so we don't support 
                // widening of primitive types here.
                // 
                object[] objects = array as object[]; 
                if( objects == null) {
                    ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType); 
                }

                int count = list.Count;
                try { 
                    for (int i = 0; i < count; i++) {
                        objects[index++] = list[i]; 
                    } 
                }
                catch(ArrayTypeMismatchException) { 
                    ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType);
                }
            }
        } 

        bool IList.IsFixedSize { 
            get { return true; } 
        }
 
        bool IList.IsReadOnly {
            get { return true; }
        }
 
        object IList.this[int index] {
            get { return list[index]; } 
            set { 
                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
            } 
        }

        int IList.Add(object value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
            return -1;
        } 
 
        void IList.Clear() {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
        }

        private static bool IsCompatibleObject(object value) {
            if( (value is T) || ( value == null && !typeof(T).IsValueType) ) { 
                return true;
            } 
            return false; 
        }
 
        bool IList.Contains(object value) {
            if(IsCompatibleObject(value)) {
                return Contains((T)value);
            } 
            return false;
        } 
 
        int IList.IndexOf(object value) {
            if(IsCompatibleObject(value)) { 
                return IndexOf((T)value);
            }
            return -1;
        } 

        void IList.Insert(int index, object value) { 
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
        }
 
        void IList.Remove(object value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        }
 
        void IList.RemoveAt(int index) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
        } 

        private static void VerifyValueType(object value) { 
            if( !IsCompatibleObject(value)) {
                ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
            }
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
namespace System.Collections.ObjectModel 
{
    using System;
    using System.Collections;
    using System.Collections.Generic; 
    using System.Diagnostics;
 
    [Serializable()] 
    [System.Runtime.InteropServices.ComVisible(false)]
    [DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))] 
    [DebuggerDisplay("Count = {Count}")]
    public class ReadOnlyCollection: IList, IList
    {
        IList list; 
        [NonSerialized]
        private Object _syncRoot; 
 
        public ReadOnlyCollection(IList list) {
            if (list == null) { 
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
            }
            this.list = list;
        } 

        public int Count { 
            get { return list.Count; } 
        }
 
        public T this[int index] {
            get { return list[index]; }
        }
 
        public bool Contains(T value) {
            return list.Contains(value); 
        } 

        public void CopyTo(T[] array, int index) { 
            list.CopyTo(array, index);
        }

        public IEnumerator GetEnumerator() { 
            return list.GetEnumerator();
        } 
 
        public int IndexOf(T value) {
            return list.IndexOf(value); 
        }

        protected IList Items {
            get { 
                return list;
            } 
        } 

        bool ICollection.IsReadOnly { 
            get { return true; }
        }

        T IList.this[int index] { 
            get { return list[index]; }
            set { 
                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
            }
        } 

        void ICollection.Add(T value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        } 

        void ICollection.Clear() { 
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
        }
 
        void IList.Insert(int index, T value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        }
 
        bool ICollection.Remove(T value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
            return false; 
        }
 
        void IList.RemoveAt(int index) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        }
 
        IEnumerator IEnumerable.GetEnumerator() {
            return ((IEnumerable)list).GetEnumerator(); 
        } 

        bool ICollection.IsSynchronized { 
            get { return false; }
        }

        object ICollection.SyncRoot { 
            get {
                if( _syncRoot == null) { 
                    ICollection c = list as ICollection; 
                    if( c != null) {
                        _syncRoot = c.SyncRoot; 
                    }
                    else {
                        System.Threading.Interlocked.CompareExchange(ref _syncRoot, new Object(), null);
                    } 
                }
                return _syncRoot; 
            } 
        }
 
        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.GetLowerBound(0) != 0 ) {
                ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
            }
 
            if (index < 0) {
                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.arrayIndex, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum); 
            } 

            if (array.Length - index < Count) { 
                ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
            }

            T[] items = array as T[]; 
            if (items != null) {
                list.CopyTo(items, index); 
            } 
            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 sourceType = typeof(T); 
                if(!(targetType.IsAssignableFrom(sourceType) || sourceType.IsAssignableFrom(targetType))) {
                    ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType); 
                }

                //
                // We can't cast array of value type to object[], so we don't support 
                // widening of primitive types here.
                // 
                object[] objects = array as object[]; 
                if( objects == null) {
                    ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType); 
                }

                int count = list.Count;
                try { 
                    for (int i = 0; i < count; i++) {
                        objects[index++] = list[i]; 
                    } 
                }
                catch(ArrayTypeMismatchException) { 
                    ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType);
                }
            }
        } 

        bool IList.IsFixedSize { 
            get { return true; } 
        }
 
        bool IList.IsReadOnly {
            get { return true; }
        }
 
        object IList.this[int index] {
            get { return list[index]; } 
            set { 
                ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
            } 
        }

        int IList.Add(object value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
            return -1;
        } 
 
        void IList.Clear() {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
        }

        private static bool IsCompatibleObject(object value) {
            if( (value is T) || ( value == null && !typeof(T).IsValueType) ) { 
                return true;
            } 
            return false; 
        }
 
        bool IList.Contains(object value) {
            if(IsCompatibleObject(value)) {
                return Contains((T)value);
            } 
            return false;
        } 
 
        int IList.IndexOf(object value) {
            if(IsCompatibleObject(value)) { 
                return IndexOf((T)value);
            }
            return -1;
        } 

        void IList.Insert(int index, object value) { 
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
        }
 
        void IList.Remove(object value) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
        }
 
        void IList.RemoveAt(int index) {
            ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection); 
        } 

        private static void VerifyValueType(object value) { 
            if( !IsCompatibleObject(value)) {
                ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
            }
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• WindowsSlider.cs
• _OverlappedAsyncResult.cs
• TabPageDesigner.cs
• DataGridViewRowCollection.cs
• EventPropertyMap.cs
• SqlRowUpdatedEvent.cs
• AsyncResult.cs
• PtsPage.cs
• QuadTree.cs
• TemplateParser.cs
• FontUnitConverter.cs
• DataGridLinkButton.cs
• ReferencedType.cs
• Logging.cs
• ComEventsHelper.cs
• SpecialFolderEnumConverter.cs
• SID.cs
• ChangesetResponse.cs
• CollectionContainer.cs
• ValidationHelper.cs
• codemethodreferenceexpression.cs
• PropertyRecord.cs
• MonthCalendar.cs
• GPRECT.cs
• ServiceSettingsResponseInfo.cs
• GPRECTF.cs
• Image.cs
• DoubleCollectionValueSerializer.cs
• CompiledQuery.cs
• MissingManifestResourceException.cs
• ExpandCollapsePattern.cs
• QueryOutputWriter.cs
• mansign.cs
• WorkBatch.cs
• XmlSchemaSet.cs
• ComplexPropertyEntry.cs
• ItemsPanelTemplate.cs
• ServiceCredentialsElement.cs
• Vector3DCollectionConverter.cs
• TextEditorSelection.cs
• HtmlFormWrapper.cs
• HScrollBar.cs
• DirectoryObjectSecurity.cs
• Geometry.cs
• NamespaceDecl.cs
• HyperLinkStyle.cs
• BinaryObjectInfo.cs
• Button.cs
• ConfigErrorGlyph.cs
• SelectingProviderEventArgs.cs
• Main.cs
• FunctionDescription.cs
• TransactionChannel.cs
• LinkArea.cs
• PrintDialog.cs
• OleDbCommandBuilder.cs
• HtmlControl.cs
• EventWaitHandleSecurity.cs
• SmiMetaDataProperty.cs
• WmiEventSink.cs
• RepeatInfo.cs
• Activation.cs
• PropertyValueEditor.cs
• KeyBinding.cs
• DataGridView.cs
• XmlIlVisitor.cs
• LexicalChunk.cs
• TextCompositionEventArgs.cs
• COM2EnumConverter.cs
• DBBindings.cs
• IProvider.cs
• XmlExceptionHelper.cs
• StatusBar.cs
• Color.cs
• WinFormsSecurity.cs
• XmlTextEncoder.cs
• ProvidePropertyAttribute.cs
• SectionUpdates.cs
• CodeParameterDeclarationExpressionCollection.cs
• ReadOnlyHierarchicalDataSource.cs
• WebReferencesBuildProvider.cs
• SafeRightsManagementHandle.cs
• FileVersionInfo.cs
• Pair.cs
• IndexedDataBuffer.cs
• CatalogPartCollection.cs
• DataSetMappper.cs
• DataGridTemplateColumn.cs
• EdmError.cs
• AnnotationComponentManager.cs
• DoubleLinkListEnumerator.cs
• CodeCompileUnit.cs
• CountdownEvent.cs
• CommentGlyph.cs
• ResourceLoader.cs
• CacheAxisQuery.cs
• ParameterBuilder.cs
• UriSection.cs
• FactoryId.cs
• sqlmetadatafactory.cs