netcore/System.Private.CoreLib/shared/System/Collections/ObjectModel/ReadOnlyCollection.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Collections.Generic;
   6 using System.Diagnostics;
   7
   8 namespace System.Collections.ObjectModel
   9 {
  10     [Serializable]
  11     [DebuggerTypeProxy(typeof(ICollectionDebugView<>))]
  12     [DebuggerDisplay("Count = {Count}")]
  13     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
  14     public class ReadOnlyCollection<T> : IList<T>, IList, IReadOnlyList<T>
  15     {
  16         private readonly IList<T> list; // Do not rename (binary serialization)
  17
  18         public ReadOnlyCollection(IList<T> list)
  19         {
  20             if (list == null)
  21             {
  22                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
  23             }
  24             this.list = list;
  25         }
  26
  27         public int Count => list.Count;
  28
  29         public T this[int index]
  30         {
  31             get { return list[index]; }
  32         }
  33
  34         public bool Contains(T value)
  35         {
  36             return list.Contains(value);
  37         }
  38
  39         public void CopyTo(T[] array, int index)
  40         {
  41             list.CopyTo(array, index);
  42         }
  43
  44         public IEnumerator<T> GetEnumerator()
  45         {
  46             return list.GetEnumerator();
  47         }
  48
  49         public int IndexOf(T value)
  50         {
  51             return list.IndexOf(value);
  52         }
  53
  54         protected IList<T> Items => list;
  55
  56         bool ICollection<T>.IsReadOnly => true;
  57
  58         T IList<T>.this[int index]
  59         {
  60             get { return list[index]; }
  61             set
  62             {
  63                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
  64             }
  65         }
  66
  67         void ICollection<T>.Add(T value)
  68         {
  69             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
  70         }
  71
  72         void ICollection<T>.Clear()
  73         {
  74             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
  75         }
  76
  77         void IList<T>.Insert(int index, T value)
  78         {
  79             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
  80         }
  81
  82         bool ICollection<T>.Remove(T value)
  83         {
  84             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
  85             return false;
  86         }
  87
  88         void IList<T>.RemoveAt(int index)
  89         {
  90             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
  91         }
  92
  93         IEnumerator IEnumerable.GetEnumerator()
  94         {
  95             return ((IEnumerable)list).GetEnumerator();
  96         }
  97
  98         bool ICollection.IsSynchronized => false;
  99
 100         object ICollection.SyncRoot => list is ICollection coll ? coll.SyncRoot : this;
 101
 102         void ICollection.CopyTo(Array array, int index)
 103         {
 104             if (array == null)
 105             {
 106                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
 107             }
 108
 109             if (array.Rank != 1)
 110             {
 111                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
 112             }
 113
 114             if (array.GetLowerBound(0) != 0)
 115             {
 116                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
 117             }
 118
 119             if (index < 0)
 120             {
 121                 ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
 122             }
 123
 124             if (array.Length - index < Count)
 125             {
 126                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
 127             }
 128
 129             if (array is T[] items)
 130             {
 131                 list.CopyTo(items, index);
 132             }
 133             else
 134             {
 135                 //
 136                 // Catch the obvious case assignment will fail.
 137                 // We can't find all possible problems by doing the check though.
 138                 // For example, if the element type of the Array is derived from T,
 139                 // we can't figure out if we can successfully copy the element beforehand.
 140                 //
 141                 Type targetType = array.GetType().GetElementType()!;
 142                 Type sourceType = typeof(T);
 143                 if (!(targetType.IsAssignableFrom(sourceType) || sourceType.IsAssignableFrom(targetType)))
 144                 {
 145                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
 146                 }
 147
 148                 //
 149                 // We can't cast array of value type to object[], so we don't support
 150                 // widening of primitive types here.
 151                 //
 152                 object?[]? objects = array as object[];
 153                 if (objects == null)
 154                 {
 155                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
 156                 }
 157
 158                 int count = list.Count;
 159                 try
 160                 {
 161                     for (int i = 0; i < count; i++)
 162                     {
 163                         objects[index++] = list[i];
 164                     }
 165                 }
 166                 catch (ArrayTypeMismatchException)
 167                 {
 168                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
 169                 }
 170             }
 171         }
 172
 173         bool IList.IsFixedSize => true;
 174
 175         bool IList.IsReadOnly => true;
 176
 177         object? IList.this[int index]
 178         {
 179             get { return list[index]; }
 180             set
 181             {
 182                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 183             }
 184         }
 185
 186         int IList.Add(object? value)
 187         {
 188             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 189             return -1;
 190         }
 191
 192         void IList.Clear()
 193         {
 194             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 195         }
 196
 197         private static bool IsCompatibleObject(object? value)
 198         {
 199             // Non-null values are fine.  Only accept nulls if T is a class or Nullable<U>.
 200             // Note that default(T) is not equal to null for value types except when T is Nullable<U>.
 201             return ((value is T) || (value == null && default(T)! == null));
 202         }
 203
 204         bool IList.Contains(object? value)
 205         {
 206             if (IsCompatibleObject(value))
 207             {
 208                 return Contains((T)value!);
 209             }
 210             return false;
 211         }
 212
 213         int IList.IndexOf(object? value)
 214         {
 215             if (IsCompatibleObject(value))
 216             {
 217                 return IndexOf((T)value!);
 218             }
 219             return -1;
 220         }
 221
 222         void IList.Insert(int index, object? value)
 223         {
 224             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 225         }
 226
 227         void IList.Remove(object? value)
 228         {
 229             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 230         }
 231
 232         void IList.RemoveAt(int index)
 233         {
 234             ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 235         }
 236     }
 237 }