netcore/System.Private.CoreLib/src/System/Array.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 Internal.Runtime.CompilerServices;
   6 using System.Collections;
   7 using System.Collections.Generic;
   8 using System.Runtime.CompilerServices;
   9 using System.Runtime.InteropServices;
  10
  11 namespace System
  12 {
  13         partial class Array
  14         {
  15                 [StructLayout(LayoutKind.Sequential)]
  16                 private class RawData
  17                 {
  18                         public IntPtr Bounds;
  19                         public IntPtr Count;
  20                         public byte Data;
  21                 }
  22
  23                 public int Length {
  24                         get {
  25                                 int length = GetLength (0);
  26
  27                                 for (int i = 1; i < Rank; i++) {
  28                                         length *= GetLength (i);
  29                                 }
  30                                 return length;
  31                         }
  32                 }
  33
  34                 public long LongLength {
  35                         get {
  36                                 long length = GetLength (0);
  37
  38                                 for (int i = 1; i < Rank; i++) {
  39                                         length *= GetLength (i);
  40                                 }
  41                                 return length;
  42                         }
  43                 }
  44
  45                 public int Rank {
  46                         get {
  47                                 return GetRank ();
  48                         }
  49                 }
  50
  51                 public static void Clear (Array array, int index, int length)
  52                 {
  53                         if (array == null)
  54                                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
  55                         if (length < 0)
  56                                 ThrowHelper.ThrowIndexOutOfRangeException();
  57
  58                         int low = array!.GetLowerBound (0);
  59                         if (index < low)
  60                                 ThrowHelper.ThrowIndexOutOfRangeException();
  61
  62                         index = index - low;
  63
  64                         // re-ordered to avoid possible integer overflow
  65                         if (index > array.Length - length)
  66                                 ThrowHelper.ThrowIndexOutOfRangeException();
  67
  68                         ClearInternal (array, index, length);
  69                 }
  70
  71                 public static void ConstrainedCopy (Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
  72                 {
  73                         Copy (sourceArray, sourceIndex, destinationArray, destinationIndex, length, true);
  74                 }
  75
  76                 public static void Copy (Array sourceArray, Array destinationArray, int length)
  77                 {
  78                         if (sourceArray == null)
  79                                 throw new ArgumentNullException ("sourceArray");
  80
  81                         if (destinationArray == null)
  82                                 throw new ArgumentNullException ("destinationArray");
  83
  84                         Copy (sourceArray, sourceArray.GetLowerBound (0), destinationArray,
  85                                 destinationArray.GetLowerBound (0), length);
  86                 }
  87
  88                 public static void Copy (Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
  89                 {
  90                         Copy (sourceArray, sourceIndex, destinationArray, destinationIndex, length, false);
  91                 }
  92
  93                 private static void Copy (Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length, bool reliable)
  94                 {
  95                         if (sourceArray == null)
  96                                 throw new ArgumentNullException (nameof (sourceArray));
  97
  98                         if (destinationArray == null)
  99                                 throw new ArgumentNullException (nameof (destinationArray));
 100
 101                         if (length < 0)
 102                                 throw new ArgumentOutOfRangeException (nameof (length), "Value has to be >= 0.");
 103
 104                         if (sourceArray.Rank != destinationArray.Rank)
 105                                 throw new RankException(SR.Rank_MultiDimNotSupported);
 106
 107                         if (sourceIndex < 0)
 108                                 throw new ArgumentOutOfRangeException (nameof (sourceIndex), "Value has to be >= 0.");
 109
 110                         if (destinationIndex < 0)
 111                                 throw new ArgumentOutOfRangeException (nameof (destinationIndex), "Value has to be >= 0.");
 112
 113                         if (FastCopy (sourceArray, sourceIndex, destinationArray, destinationIndex, length))
 114                                 return;
 115
 116                         int source_pos = sourceIndex - sourceArray.GetLowerBound (0);
 117                         int dest_pos = destinationIndex - destinationArray.GetLowerBound (0);
 118
 119                         if (source_pos < 0)
 120                                 throw new ArgumentOutOfRangeException (nameof (sourceIndex), "Index was less than the array's lower bound in the first dimension.");
 121
 122                         if (dest_pos < 0)
 123                                 throw new ArgumentOutOfRangeException (nameof (destinationIndex), "Index was less than the array's lower bound in the first dimension.");
 124
 125                         // re-ordered to avoid possible integer overflow
 126                         if (source_pos > sourceArray.Length - length)
 127                                 throw new ArgumentException (SR.Arg_LongerThanSrcArray, nameof (sourceArray));
 128
 129                         if (dest_pos > destinationArray.Length - length) {
 130                                 throw new ArgumentException ("Destination array was not long enough. Check destIndex and length, and the array's lower bounds", nameof (destinationArray));
 131                         }
 132
 133                         Type src_type = sourceArray.GetType ().GetElementType ()!;
 134                         Type dst_type = destinationArray.GetType ().GetElementType ()!;
 135                         var dst_type_vt = dst_type.IsValueType && Nullable.GetUnderlyingType (dst_type) == null;
 136
 137                         bool src_is_enum = src_type.IsEnum;
 138                         bool dst_is_enum = dst_type.IsEnum;
 139
 140                         if (src_is_enum)
 141                                 src_type = Enum.GetUnderlyingType (src_type);
 142                         if (dst_is_enum)
 143                                 dst_type = Enum.GetUnderlyingType (dst_type);
 144
 145                         if (reliable) {
 146                                 if (!dst_type.Equals (src_type) &&
 147                                         !(dst_type.IsPrimitive && src_type.IsPrimitive && CanChangePrimitive(dst_type, src_type, true))) {
 148                                         throw new ArrayTypeMismatchException (SR.ArrayTypeMismatch_CantAssignType);
 149                                 }
 150                         } else {
 151                                 if (!CanAssignArrayElement (src_type, dst_type)) {
 152                                         throw new ArrayTypeMismatchException (SR.ArrayTypeMismatch_CantAssignType);
 153                                 }
 154                         }
 155
 156                         if (!Object.ReferenceEquals (sourceArray, destinationArray) || source_pos > dest_pos) {
 157                                 for (int i = 0; i < length; i++) {
 158                                         Object srcval = sourceArray.GetValueImpl (source_pos + i);
 159
 160                                         if (!src_type.IsValueType && dst_is_enum)
 161                                                 throw new InvalidCastException (SR.InvalidCast_DownCastArrayElement);
 162
 163                                         if (dst_type_vt && (srcval == null || (src_type == typeof (object) && srcval.GetType () != dst_type)))
 164                                                 throw new InvalidCastException ();
 165
 166                                         try {
 167                                                 destinationArray.SetValueRelaxedImpl (srcval, dest_pos + i);
 168                                         } catch (ArgumentException) {
 169                                                 throw CreateArrayTypeMismatchException ();
 170                                         }
 171                                 }
 172                         } else {
 173                                 for (int i = length - 1; i >= 0; i--) {
 174                                         Object srcval = sourceArray.GetValueImpl (source_pos + i);
 175
 176                                         try {
 177                                                 destinationArray.SetValueRelaxedImpl (srcval, dest_pos + i);
 178                                         } catch (ArgumentException) {
 179                                                 throw CreateArrayTypeMismatchException ();
 180                                         }
 181                                 }
 182                         }
 183                 }
 184
 185                 static ArrayTypeMismatchException CreateArrayTypeMismatchException ()
 186                 {
 187                         return new ArrayTypeMismatchException ();
 188                 }
 189
 190                 static bool CanAssignArrayElement (Type source, Type target)
 191                 {
 192                         if (!target.IsValueType && !target.IsPointer) {
 193                                 if (!source.IsValueType && !source.IsPointer) {
 194                                         // Reference to reference copy
 195                                         return
 196                                                 source.IsInterface || target.IsInterface ||
 197                                                 source.IsAssignableFrom (target) || target.IsAssignableFrom (source);
 198                                 } else {
 199                                         // Value to reference copy
 200                                         if (source.IsPointer)
 201                                                 return false;
 202                                         return target.IsAssignableFrom (source);
 203                                 }
 204                         } else {
 205                                 if (source.IsEquivalentTo (target)) {
 206                                         return true;
 207                                 } else if (source.IsPointer && target.IsPointer) {
 208                                         return true;
 209                                 } else if (source.IsPrimitive && target.IsPrimitive) {
 210
 211                                         // Allow primitive type widening
 212                                         return CanChangePrimitive (source, target, false);
 213                                 } else if (!source.IsValueType && !source.IsPointer) {
 214                                         // Source is base class or interface of destination type
 215                                         if (target.IsPointer)
 216                                                 return false;
 217                                         return source.IsAssignableFrom (target);
 218                                 }
 219                         }
 220
 221                         return false;
 222                 }
 223
 224                 public static Array CreateInstance (Type elementType, int length)
 225                 {
 226                         if (length < 0)
 227                                 throw new ArgumentOutOfRangeException (nameof (length));
 228
 229                         int[] lengths = {length};
 230
 231                         return CreateInstance (elementType, lengths);
 232                 }
 233
 234                 public static Array CreateInstance (Type elementType, int length1, int length2)
 235                 {
 236                         if (length1 < 0)
 237                                 throw new ArgumentOutOfRangeException (nameof (length1));
 238                         if (length2 < 0)
 239                                 throw new ArgumentOutOfRangeException (nameof (length2));
 240
 241                         int[] lengths = {length1, length2};
 242
 243                         return CreateInstance (elementType, lengths);
 244                 }
 245
 246                 public static Array CreateInstance (Type elementType, int length1, int length2, int length3)
 247                 {
 248                         if (length1 < 0)
 249                                 throw new ArgumentOutOfRangeException (nameof (length1));
 250                         if (length2 < 0)
 251                                 throw new ArgumentOutOfRangeException (nameof (length2));
 252                         if (length3 < 0)
 253                                 throw new ArgumentOutOfRangeException (nameof (length3));
 254
 255                         int[] lengths = {length1, length2, length3};
 256
 257                         return CreateInstance (elementType, lengths);
 258                 }
 259
 260                 public static Array CreateInstance (Type elementType, params int[] lengths)
 261                 {
 262                         if (elementType == null)
 263                                 throw new ArgumentNullException ("elementType");
 264                         if (lengths == null)
 265                                 throw new ArgumentNullException ("lengths");
 266                         if (lengths.Length == 0)
 267                                 throw new ArgumentException (nameof (lengths));
 268                         if (lengths.Length > 255)
 269                                 throw new TypeLoadException ();
 270                         for (int i = 0; i < lengths.Length; ++i) {
 271                                 if (lengths [i] < 0)
 272                                         throw new ArgumentOutOfRangeException ($"lengths[{i}]", SR.ArgumentOutOfRange_NeedNonNegNum);
 273                         }
 274
 275                         if (!(elementType.UnderlyingSystemType is RuntimeType et))
 276                                 throw new ArgumentException ("Type must be a type provided by the runtime.", "elementType");
 277                         if (et.Equals (typeof (void)))
 278                                 throw new NotSupportedException ("Array type can not be void");
 279                         if (et.ContainsGenericParameters)
 280                                 throw new NotSupportedException ("Array type can not be an open generic type");
 281                         if (et.IsByRef)
 282                                 throw new NotSupportedException (SR.NotSupported_Type);
 283
 284                         return CreateInstanceImpl (et, lengths, null);
 285                 }
 286
 287                 public static Array CreateInstance (Type elementType, int[] lengths, int [] lowerBounds)
 288                 {
 289                         if (elementType == null)
 290                                 throw new ArgumentNullException ("elementType");
 291                         if (lengths == null)
 292                                 throw new ArgumentNullException ("lengths");
 293                         if (lowerBounds == null)
 294                                 throw new ArgumentNullException ("lowerBounds");
 295
 296                         if (!(elementType.UnderlyingSystemType is RuntimeType rt))
 297                                 throw new ArgumentException ("Type must be a type provided by the runtime.", "elementType");
 298                         if (rt.Equals (typeof (void)))
 299                                 throw new NotSupportedException ("Array type can not be void");
 300                         if (rt.ContainsGenericParameters)
 301                                 throw new NotSupportedException ("Array type can not be an open generic type");
 302                         if (rt.IsByRef)
 303                                 throw new NotSupportedException (SR.NotSupported_Type);
 304
 305                         if (lengths.Length < 1)
 306                                 throw new ArgumentException ("Arrays must contain >= 1 elements.");
 307
 308                         if (lengths.Length != lowerBounds.Length)
 309                                 throw new ArgumentException ("Arrays must be of same size.");
 310
 311                         for (int j = 0; j < lowerBounds.Length; j ++) {
 312                                 if (lengths [j] < 0)
 313                                         throw new ArgumentOutOfRangeException ($"lengths[{j}]", "Each value has to be >= 0.");
 314                                 if ((long)lowerBounds [j] + (long)lengths [j] > (long)Int32.MaxValue)
 315                                         throw new ArgumentOutOfRangeException (null, "Length + bound must not exceed Int32.MaxValue.");
 316                         }
 317
 318                         if (lengths.Length > 255)
 319                                 throw new TypeLoadException ();
 320
 321                         return CreateInstanceImpl (elementType, lengths, lowerBounds);
 322                 }
 323
 324                 public object GetValue (int index)
 325                 {
 326                         if (Rank != 1)
 327                                 ThrowHelper.ThrowArgumentException (ExceptionResource.Arg_Need1DArray);
 328
 329                         var lb  = GetLowerBound (0);
 330                         if (index < lb || index > GetUpperBound (0))
 331                                 throw new IndexOutOfRangeException ("Index has to be between upper and lower bound of the array.");
 332
 333                         if (GetType ().GetElementType ()!.IsPointer)
 334                                 throw new NotSupportedException (SR.NotSupported_Type);
 335
 336                         return GetValueImpl (index - lb);
 337                 }
 338
 339                 public object GetValue (int index1, int index2)
 340                 {
 341                         if (Rank != 2)
 342                                 ThrowHelper.ThrowArgumentException (ExceptionResource.Arg_Need2DArray);
 343
 344                         int[] ind = {index1, index2};
 345                         return GetValue (ind);
 346                 }
 347
 348                 public object GetValue (int index1, int index2, int index3)
 349                 {
 350                         if (Rank != 3)
 351                                 ThrowHelper.ThrowArgumentException (ExceptionResource.Arg_Need3DArray);
 352
 353                         int[] ind = {index1, index2, index3};
 354                         return GetValue (ind);
 355                 }
 356
 357                 public void Initialize ()
 358                 {
 359                 }
 360
 361                 static int IndexOfImpl<T>(T[] array, T value, int startIndex, int count)
 362                 {
 363                         return EqualityComparer<T>.Default.IndexOf (array, value, startIndex, count);
 364                 }
 365
 366                 static int LastIndexOfImpl<T>(T[] array, T value, int startIndex, int count)
 367                 {
 368                         return EqualityComparer<T>.Default.LastIndexOf (array, value, startIndex, count);
 369                 }
 370
 371                 public void SetValue (object? value, int index)
 372                 {
 373                         if (Rank != 1)
 374                                 ThrowHelper.ThrowArgumentException (ExceptionResource.Arg_Need1DArray);
 375
 376                         var lb  = GetLowerBound (0);
 377                         if (index < lb || index > GetUpperBound (0))
 378                                 throw new IndexOutOfRangeException ("Index has to be >= lower bound and <= upper bound of the array.");
 379
 380                         if (GetType ().GetElementType ()!.IsPointer)
 381                                 throw new NotSupportedException (SR.NotSupported_Type);
 382
 383                         SetValueImpl (value, index - lb);
 384                 }
 385
 386                 public void SetValue (object? value, int index1, int index2)
 387                 {
 388                         if (Rank != 2)
 389                                 ThrowHelper.ThrowArgumentException (ExceptionResource.Arg_Need2DArray);
 390
 391                         int[] ind = {index1, index2};
 392                         SetValue (value, ind);
 393                 }
 394
 395                 public void SetValue (object? value, int index1, int index2, int index3)
 396                 {
 397                         if (Rank != 3)
 398                                 ThrowHelper.ThrowArgumentException (ExceptionResource.Arg_Need3DArray);
 399
 400                         int[] ind = {index1, index2, index3};
 401                         SetValue (value, ind);
 402                 }
 403
 404                 static void SortImpl (Array keys, Array? items, int index, int length, IComparer comparer)
 405                 {
 406                         /* TODO: CoreCLR optimizes this case via an internal call
 407                         if (comparer == Comparer.Default)
 408                         {
 409                                 bool r = TrySZSort(keys, items, index, index + length - 1);
 410                                 if (r)
 411                                         return;
 412                         }*/
 413
 414                         object[]? objKeys = keys as object[];
 415                         object[]? objItems = null;
 416                         if (objKeys != null)
 417                                 objItems = items as object[];
 418                         if (objKeys != null && (items == null || objItems != null)) {
 419                                 SorterObjectArray sorter = new SorterObjectArray (objKeys, objItems, comparer);
 420                                 sorter.Sort(index, length);
 421                         } else {
 422                                 SorterGenericArray sorter = new SorterGenericArray (keys, items, comparer);
 423                                 sorter.Sort(index, length);
 424                         }
 425                 }
 426
 427                 public int GetUpperBound (int dimension)
 428                 {
 429                         return GetLowerBound (dimension) + GetLength (dimension) - 1;
 430                 }
 431
 432                 [MethodImpl (MethodImplOptions.AggressiveInlining)]
 433                 internal ref byte GetRawSzArrayData ()
 434                 {
 435                         return ref Unsafe.As<RawData>(this).Data;
 436                 }
 437
 438                 [MethodImpl (MethodImplOptions.AggressiveInlining)]
 439                 internal ref byte GetRawArrayData ()
 440                 {
 441                         return ref Unsafe.As<RawData>(this).Data;
 442                 }
 443
 444                 internal int GetElementSize ()
 445                 {
 446                         return Marshal.GetArrayElementSize (GetType ());
 447                 }
 448
 449                 //
 450                 // Moved value from instance into target of different type with no checks (JIT intristics)
 451                 //
 452                 // Restrictions:
 453                 //
 454                 // S and R must either:
 455                 //       both be blitable valuetypes
 456                 //       both be reference types (IOW, an unsafe cast)
 457                 // S and R cannot be float or double
 458                 // S and R must either:
 459                 //       both be a struct
 460                 //       both be a scalar
 461                 // S and R must either:
 462                 //       be of same size
 463                 //       both be a scalar of size <= 4
 464                 //
 465                 internal static R UnsafeMov<S,R> (S instance)
 466                 {
 467                         return (R)(object) instance;
 468                 }
 469
 470                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 471                 extern static void ClearInternal (Array a, int index, int count);
 472
 473                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 474                 extern static Array CreateInstanceImpl (Type elementType, int[] lengths, int[]? bounds);
 475
 476                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 477                 extern static bool CanChangePrimitive (Type srcType, Type dstType, bool reliable);
 478
 479                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 480                 internal extern static bool FastCopy (Array source, int source_idx, Array dest, int dest_idx, int length);
 481
 482                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 483                 extern int GetRank ();
 484
 485                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 486                 public extern int GetLength (int dimension);
 487
 488                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 489                 public extern int GetLowerBound (int dimension);
 490
 491                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 492                 public extern object GetValue (params int[] indices);
 493
 494                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 495                 public extern void SetValue (object? value, params int[] indices);
 496
 497                 // CAUTION! No bounds checking!
 498                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 499                 extern void GetGenericValueImpl<T> (int pos, out T value);
 500
 501                 // CAUTION! No bounds checking!
 502                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 503                 extern object GetValueImpl (int pos);
 504
 505                 // CAUTION! No bounds checking!
 506                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 507                 extern void SetGenericValueImpl<T> (int pos, ref T value);
 508
 509                 // CAUTION! No bounds checking!
 510                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 511                 extern void SetValueImpl (object? value, int pos);
 512
 513                 // CAUTION! No bounds checking!
 514                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 515                 extern void SetValueRelaxedImpl (object? value, int pos);
 516
 517                 /*
 518                  * These methods are used to implement the implicit generic interfaces
 519                  * implemented by arrays in NET 2.0.
 520                  * Only make those methods generic which really need it, to avoid
 521                  * creating useless instantiations.
 522                  */
 523                 internal int InternalArray__ICollection_get_Count ()
 524                 {
 525                         return Length;
 526                 }
 527
 528                 internal bool InternalArray__ICollection_get_IsReadOnly ()
 529                 {
 530                         return true;
 531                 }
 532
 533                 internal IEnumerator<T> InternalArray__IEnumerable_GetEnumerator<T> ()
 534                 {
 535                         return Length == 0 ? SZGenericArrayEnumerator<T>.Empty : new SZGenericArrayEnumerator<T> (Unsafe.As<T[]> (this));
 536                 }
 537
 538                 internal void InternalArray__ICollection_Clear ()
 539                 {
 540                         ThrowHelper.ThrowNotSupportedException (ExceptionResource.NotSupported_ReadOnlyCollection);
 541                 }
 542
 543                 internal void InternalArray__ICollection_Add<T> (T item)
 544                 {
 545                         ThrowHelper.ThrowNotSupportedException (ExceptionResource.NotSupported_FixedSizeCollection);
 546                 }
 547
 548                 internal bool InternalArray__ICollection_Remove<T> (T item)
 549                 {
 550                         ThrowHelper.ThrowNotSupportedException (ExceptionResource.NotSupported_FixedSizeCollection);
 551                         return default;
 552                 }
 553
 554                 internal bool InternalArray__ICollection_Contains<T> (T item)
 555                 {
 556                         return IndexOf (this, item, 0, Length) >= 0;
 557                 }
 558
 559                 internal void InternalArray__ICollection_CopyTo<T> (T[] array, int arrayIndex)
 560                 {
 561                         Copy (this, GetLowerBound (0), array, arrayIndex, Length);
 562                 }
 563
 564                 internal T InternalArray__IReadOnlyList_get_Item<T> (int index)
 565                 {
 566                         if ((uint)index >= (uint)Length)
 567                                 ThrowHelper.ThrowArgumentOutOfRange_IndexException ();
 568
 569                         T value;
 570                         GetGenericValueImpl (index, out value);
 571                         return value;
 572                 }
 573
 574                 internal int InternalArray__IReadOnlyCollection_get_Count ()
 575                 {
 576                         return Length;
 577                 }
 578
 579                 internal void InternalArray__Insert<T> (int index, T item)
 580                 {
 581                         ThrowHelper.ThrowNotSupportedException (ExceptionResource.NotSupported_FixedSizeCollection);
 582                 }
 583
 584                 internal void InternalArray__RemoveAt (int index)
 585                 {
 586                         ThrowHelper.ThrowNotSupportedException (ExceptionResource.NotSupported_FixedSizeCollection);
 587                 }
 588
 589                 internal int InternalArray__IndexOf<T> (T item)
 590                 {
 591                         return IndexOf (this, item, 0, Length);
 592                 }
 593
 594                 internal T InternalArray__get_Item<T> (int index)
 595                 {
 596                         if ((uint)index >= (uint)Length)
 597                                 ThrowHelper.ThrowArgumentOutOfRange_IndexException ();
 598
 599                         T value;
 600                         GetGenericValueImpl (index, out value);
 601                         return value;
 602                 }
 603
 604                 internal void InternalArray__set_Item<T> (int index, T item)
 605                 {
 606                         if ((uint)index >= (uint)Length)
 607                                 ThrowHelper.ThrowArgumentOutOfRange_IndexException();
 608
 609                         if (this is object[] oarray) {
 610                                 oarray! [index] = (object)item;
 611                                 return;
 612                         }
 613
 614                         SetGenericValueImpl (index, ref item);
 615                 }
 616         }
 617 }