netcore/System.Private.CoreLib/shared/System/Collections/ObjectModel/Collection.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 Collection<T> : IList<T>, IList, IReadOnlyList<T>
  15     {
  16         private readonly IList<T> items; // Do not rename (binary serialization)
  17
  18         public Collection()
  19         {
  20             items = new List<T>();
  21         }
  22
  23         public Collection(IList<T> list)
  24         {
  25             if (list == null)
  26             {
  27                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
  28             }
  29             items = list;
  30         }
  31
  32         public int Count => items.Count;
  33
  34         protected IList<T> Items => items;
  35
  36         public T this[int index]
  37         {
  38             get { return items[index]; }
  39             set
  40             {
  41                 if (items.IsReadOnly)
  42                 {
  43                     ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
  44                 }
  45
  46                 if ((uint)index >= (uint)items.Count)
  47                 {
  48                     ThrowHelper.ThrowArgumentOutOfRange_IndexException();
  49                 }
  50
  51                 SetItem(index, value);
  52             }
  53         }
  54
  55         public void Add(T item)
  56         {
  57             if (items.IsReadOnly)
  58             {
  59                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
  60             }
  61
  62             int index = items.Count;
  63             InsertItem(index, item);
  64         }
  65
  66         public void Clear()
  67         {
  68             if (items.IsReadOnly)
  69             {
  70                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
  71             }
  72
  73             ClearItems();
  74         }
  75
  76         public void CopyTo(T[] array, int index)
  77         {
  78             items.CopyTo(array, index);
  79         }
  80
  81         public bool Contains(T item)
  82         {
  83             return items.Contains(item);
  84         }
  85
  86         public IEnumerator<T> GetEnumerator()
  87         {
  88             return items.GetEnumerator();
  89         }
  90
  91         public int IndexOf(T item)
  92         {
  93             return items.IndexOf(item);
  94         }
  95
  96         public void Insert(int index, T item)
  97         {
  98             if (items.IsReadOnly)
  99             {
 100                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 101             }
 102
 103             if ((uint)index > (uint)items.Count)
 104             {
 105                 ThrowHelper.ThrowArgumentOutOfRange_IndexException();
 106             }
 107
 108             InsertItem(index, item);
 109         }
 110
 111         public bool Remove(T item)
 112         {
 113             if (items.IsReadOnly)
 114             {
 115                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 116             }
 117
 118             int index = items.IndexOf(item);
 119             if (index < 0) return false;
 120             RemoveItem(index);
 121             return true;
 122         }
 123
 124         public void RemoveAt(int index)
 125         {
 126             if (items.IsReadOnly)
 127             {
 128                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 129             }
 130
 131             if ((uint)index >= (uint)items.Count)
 132             {
 133                 ThrowHelper.ThrowArgumentOutOfRange_IndexException();
 134             }
 135
 136             RemoveItem(index);
 137         }
 138
 139         protected virtual void ClearItems()
 140         {
 141             items.Clear();
 142         }
 143
 144         protected virtual void InsertItem(int index, T item)
 145         {
 146             items.Insert(index, item);
 147         }
 148
 149         protected virtual void RemoveItem(int index)
 150         {
 151             items.RemoveAt(index);
 152         }
 153
 154         protected virtual void SetItem(int index, T item)
 155         {
 156             items[index] = item;
 157         }
 158
 159         bool ICollection<T>.IsReadOnly => items.IsReadOnly;
 160
 161         IEnumerator IEnumerable.GetEnumerator()
 162         {
 163             return ((IEnumerable)items).GetEnumerator();
 164         }
 165
 166         bool ICollection.IsSynchronized => false;
 167
 168         object ICollection.SyncRoot => items is ICollection coll ? coll.SyncRoot : this;
 169
 170         void ICollection.CopyTo(Array array, int index)
 171         {
 172             if (array == null)
 173             {
 174                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
 175             }
 176
 177             if (array.Rank != 1)
 178             {
 179                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
 180             }
 181
 182             if (array.GetLowerBound(0) != 0)
 183             {
 184                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
 185             }
 186
 187             if (index < 0)
 188             {
 189                 ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
 190             }
 191
 192             if (array.Length - index < Count)
 193             {
 194                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
 195             }
 196
 197             if (array is T[] tArray)
 198             {
 199                 items.CopyTo(tArray, index);
 200             }
 201             else
 202             {
 203                 //
 204                 // Catch the obvious case assignment will fail.
 205                 // We can't find all possible problems by doing the check though.
 206                 // For example, if the element type of the Array is derived from T,
 207                 // we can't figure out if we can successfully copy the element beforehand.
 208                 //
 209                 Type targetType = array.GetType().GetElementType()!;
 210                 Type sourceType = typeof(T);
 211                 if (!(targetType.IsAssignableFrom(sourceType) || sourceType.IsAssignableFrom(targetType)))
 212                 {
 213                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
 214                 }
 215
 216                 //
 217                 // We can't cast array of value type to object[], so we don't support
 218                 // widening of primitive types here.
 219                 //
 220                 object?[]? objects = array as object[];
 221                 if (objects == null)
 222                 {
 223                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
 224                 }
 225
 226                 int count = items.Count;
 227                 try
 228                 {
 229                     for (int i = 0; i < count; i++)
 230                     {
 231                         objects[index++] = items[i];
 232                     }
 233                 }
 234                 catch (ArrayTypeMismatchException)
 235                 {
 236                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
 237                 }
 238             }
 239         }
 240
 241         object? IList.this[int index]
 242         {
 243             get { return items[index]; }
 244             set
 245             {
 246                 ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(value, ExceptionArgument.value);
 247
 248                 T item = default(T)!;
 249
 250                 try
 251                 {
 252                     item = (T)value!;
 253                 }
 254                 catch (InvalidCastException)
 255                 {
 256                     ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
 257                 }
 258
 259                 this[index] = item;
 260             }
 261         }
 262
 263         bool IList.IsReadOnly => items.IsReadOnly;
 264
 265         bool IList.IsFixedSize
 266         {
 267             get
 268             {
 269                 // There is no IList<T>.IsFixedSize, so we must assume that only
 270                 // readonly collections are fixed size, if our internal item
 271                 // collection does not implement IList.  Note that Array implements
 272                 // IList, and therefore T[] and U[] will be fixed-size.
 273                 if (items is IList list)
 274                 {
 275                     return list.IsFixedSize;
 276                 }
 277                 return items.IsReadOnly;
 278             }
 279         }
 280
 281         int IList.Add(object? value)
 282         {
 283             if (items.IsReadOnly)
 284             {
 285                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 286             }
 287             ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(value, ExceptionArgument.value);
 288
 289             T item = default(T)!;
 290
 291             try
 292             {
 293                 item = (T)value!;
 294             }
 295             catch (InvalidCastException)
 296             {
 297                 ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
 298             }
 299
 300             Add(item);
 301
 302             return this.Count - 1;
 303         }
 304
 305         bool IList.Contains(object? value)
 306         {
 307             if (IsCompatibleObject(value))
 308             {
 309                 return Contains((T)value!);
 310             }
 311             return false;
 312         }
 313
 314         int IList.IndexOf(object? value)
 315         {
 316             if (IsCompatibleObject(value))
 317             {
 318                 return IndexOf((T)value!);
 319             }
 320             return -1;
 321         }
 322
 323         void IList.Insert(int index, object? value)
 324         {
 325             if (items.IsReadOnly)
 326             {
 327                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 328             }
 329             ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(value, ExceptionArgument.value);
 330
 331             T item = default(T)!;
 332
 333             try
 334             {
 335                 item = (T)value!;
 336             }
 337             catch (InvalidCastException)
 338             {
 339                 ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
 340             }
 341
 342             Insert(index, item);
 343         }
 344
 345         void IList.Remove(object? value)
 346         {
 347             if (items.IsReadOnly)
 348             {
 349                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
 350             }
 351
 352             if (IsCompatibleObject(value))
 353             {
 354                 Remove((T)value!);
 355             }
 356         }
 357
 358         private static bool IsCompatibleObject(object? value)
 359         {
 360             // Non-null values are fine.  Only accept nulls if T is a class or Nullable<U>.
 361             // Note that default(T) is not equal to null for value types except when T is Nullable<U>.
 362             return ((value is T) || (value == null && default(T)! == null));
 363         }
 364     }
 365 }