mcs/class/corlib/System/Array.cs

   1 //
   2 // System.Array.cs
   3 //
   4 // Authors:
   5 //   Joe Shaw (joe@ximian.com)
   6 //   Martin Baulig (martin@gnome.org)
   7 //   Dietmar Maurer (dietmar@ximian.com)
   8 //   Gonzalo Paniagua Javier (gonzalo@ximian.com)
   9 //   Jeffrey Stedfast (fejj@novell.com)
  10 //   Marek Safar (marek.safar@gmail.com)
  11 //
  12 // (C) 2001-2003 Ximian, Inc.  http://www.ximian.com
  13 // Copyright (C) 2004-2011 Novell, Inc (http://www.novell.com)
  14 // Copyright (C) 2011 Xamarin Inc (http://www.xamarin.com)
  15 //
  16 // Permission is hereby granted, free of charge, to any person obtaining
  17 // a copy of this software and associated documentation files (the
  18 // "Software"), to deal in the Software without restriction, including
  19 // without limitation the rights to use, copy, modify, merge, publish,
  20 // distribute, sublicense, and/or sell copies of the Software, and to
  21 // permit persons to whom the Software is furnished to do so, subject to
  22 // the following conditions:
  23 //
  24 // The above copyright notice and this permission notice shall be
  25 // included in all copies or substantial portions of the Software.
  26 //
  27 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  28 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  29 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  30 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  31 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  32 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  33 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  34 //
  35
  36 using System.Collections;
  37 using System.Runtime.CompilerServices;
  38 using System.Runtime.InteropServices;
  39 using System.Collections.Generic;
  40 using System.Collections.ObjectModel;
  41 using System.Runtime.ConstrainedExecution;
  42
  43 namespace System
  44 {
  45         public abstract partial class Array
  46         {
  47                 // Constructor
  48                 private Array ()
  49                 {
  50                 }
  51                 /*
  52                  * These methods are used to implement the implicit generic interfaces
  53                  * implemented by arrays in NET 2.0.
  54                  * Only make those methods generic which really need it, to avoid
  55                  * creating useless instantiations.
  56                  */
  57                 internal int InternalArray__ICollection_get_Count ()
  58                 {
  59                         return Length;
  60                 }
  61
  62                 internal bool InternalArray__ICollection_get_IsReadOnly ()
  63                 {
  64                         return true;
  65                 }
  66
  67                 // adapted to the Mono array layout
  68                 [StructLayout(LayoutKind.Sequential)]
  69                 private class RawData
  70                 {
  71                         public IntPtr Bounds;
  72                         public IntPtr Count;
  73                         public byte Data;
  74                 }
  75
  76                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
  77                 internal ref byte GetRawSzArrayData()
  78                 {
  79                         return ref Unsafe.As<RawData>(this).Data;
  80                 }
  81
  82                 internal IEnumerator<T> InternalArray__IEnumerable_GetEnumerator<T> ()
  83                 {
  84                         if (Length == 0)
  85                                 return EmptyInternalEnumerator<T>.Value;
  86                         else
  87                                 return new InternalEnumerator<T> (this);
  88                 }
  89
  90                 internal void InternalArray__ICollection_Clear ()
  91                 {
  92                         throw new NotSupportedException ("Collection is read-only");
  93                 }
  94
  95                 internal void InternalArray__ICollection_Add<T> (T item)
  96                 {
  97                         throw new NotSupportedException ("Collection is of a fixed size");
  98                 }
  99
 100                 internal bool InternalArray__ICollection_Remove<T> (T item)
 101                 {
 102                         throw new NotSupportedException ("Collection is of a fixed size");
 103                 }
 104
 105                 internal bool InternalArray__ICollection_Contains<T> (T item)
 106                 {
 107                         if (this.Rank > 1)
 108                                 throw new RankException ("Only single dimension arrays are supported.");
 109
 110                         int length = this.Length;
 111                         for (int i = 0; i < length; i++) {
 112                                 T value;
 113                                 // Do not change this to call GetGenericValue_icall directly, due to special casing in the runtime.
 114                                 GetGenericValueImpl (i, out value);
 115                                 if (item == null){
 116                                         if (value == null) {
 117                                                 return true;
 118                                         }
 119
 120                                         continue;
 121                                 }
 122
 123                                 if (item.Equals (value)) {
 124                                         return true;
 125                                 }
 126                         }
 127
 128                         return false;
 129                 }
 130
 131                 internal void InternalArray__ICollection_CopyTo<T> (T[] array, int arrayIndex)
 132                 {
 133                         Copy (this, GetLowerBound (0), array, arrayIndex, Length);
 134                 }
 135
 136                 internal T InternalArray__IReadOnlyList_get_Item<T> (int index)
 137                 {
 138                         if (unchecked ((uint) index) >= unchecked ((uint) Length))
 139                                 throw new ArgumentOutOfRangeException ("index");
 140
 141                         T value;
 142                         // Do not change this to call GetGenericValue_icall directly, due to special casing in the runtime.
 143                         GetGenericValueImpl (index, out value);
 144                         return value;
 145                 }
 146
 147                 internal int InternalArray__IReadOnlyCollection_get_Count ()
 148                 {
 149                         return Length;
 150                 }
 151
 152                 internal void InternalArray__Insert<T> (int index, T item)
 153                 {
 154                         throw new NotSupportedException ("Collection is of a fixed size");
 155                 }
 156
 157                 internal void InternalArray__RemoveAt (int index)
 158                 {
 159                         throw new NotSupportedException ("Collection is of a fixed size");
 160                 }
 161
 162                 internal int InternalArray__IndexOf<T> (T item)
 163                 {
 164                         if (this.Rank > 1)
 165                                 throw new RankException ("Only single dimension arrays are supported.");
 166
 167                         int length = this.Length;
 168                         for (int i = 0; i < length; i++) {
 169                                 T value;
 170                                 // Do not change this to call GetGenericValue_icall directly, due to special casing in the runtime.
 171                                 GetGenericValueImpl (i, out value);
 172                                 if (item == null){
 173                                         if (value == null)
 174                                                 return i + this.GetLowerBound (0);
 175
 176                                         continue;
 177                                 }
 178                                 if (value.Equals (item))
 179                                         // array index may not be zero-based.
 180                                         // use lower bound
 181                                         return i + this.GetLowerBound (0);
 182                         }
 183
 184                         unchecked {
 185                                 // lower bound may be MinValue
 186                                 return this.GetLowerBound (0) - 1;
 187                         }
 188                 }
 189
 190                 internal T InternalArray__get_Item<T> (int index)
 191                 {
 192                         if (unchecked ((uint) index) >= unchecked ((uint) Length))
 193                                 throw new ArgumentOutOfRangeException ("index");
 194
 195                         T value;
 196                         // Do not change this to call GetGenericValue_icall directly, due to special casing in the runtime.
 197                         GetGenericValueImpl (index, out value);
 198                         return value;
 199                 }
 200
 201                 internal void InternalArray__set_Item<T> (int index, T item)
 202                 {
 203                         if (unchecked ((uint) index) >= unchecked ((uint) Length))
 204                                 throw new ArgumentOutOfRangeException ("index");
 205
 206                         object[] oarray = this as object [];
 207                         if (oarray != null) {
 208                                 oarray [index] = (object)item;
 209                                 return;
 210                         }
 211                         // Do not change this to call SetGenericValue_icall directly, due to special casing in the runtime.
 212                         SetGenericValueImpl (index, ref item);
 213                 }
 214
 215                 // CAUTION! No bounds checking!
 216                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 217                 extern static void GetGenericValue_icall<T> (ref Array self, int pos, out T value);
 218
 219                 // CAUTION! No bounds checking!
 220                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 221                 extern static void SetGenericValue_icall<T> (ref Array self, int pos, ref T value);
 222
 223                 // This is a special case in the runtime.
 224                 internal void GetGenericValueImpl<T> (int pos, out T value)
 225                 {
 226                         var self = this;
 227                         GetGenericValue_icall (ref self, pos, out value);
 228                 }
 229
 230                 // This is a special case in the runtime.
 231                 internal void SetGenericValueImpl<T> (int pos, ref T value)
 232                 {
 233                         var self = this;
 234                         SetGenericValue_icall (ref self, pos, ref value);
 235                 }
 236
 237                 internal struct InternalEnumerator<T> : IEnumerator<T>
 238                 {
 239                         const int NOT_STARTED = -2;
 240
 241                         // this MUST be -1, because we depend on it in move next.
 242                         // we just decr the size, so, 0 - 1 == FINISHED
 243                         const int FINISHED = -1;
 244
 245                         readonly Array array;
 246                         int idx;
 247
 248                         internal InternalEnumerator (Array array)
 249                         {
 250                                 this.array = array;
 251                                 idx = NOT_STARTED;
 252                         }
 253
 254                         public void Dispose ()
 255                         {
 256                         }
 257
 258                         public bool MoveNext ()
 259                         {
 260                                 if (idx == NOT_STARTED)
 261                                         idx = array.Length;
 262
 263                                 return idx != FINISHED && -- idx != FINISHED;
 264                         }
 265
 266                         public T Current {
 267                                 get {
 268                                         if (idx == NOT_STARTED)
 269                                                 throw new InvalidOperationException ("Enumeration has not started. Call MoveNext");
 270                                         if (idx == FINISHED)
 271                                                 throw new InvalidOperationException ("Enumeration already finished");
 272
 273                                         return array.InternalArray__get_Item<T> (array.Length - 1 - idx);
 274                                 }
 275                         }
 276
 277                         void IEnumerator.Reset ()
 278                         {
 279                                 idx = NOT_STARTED;
 280                         }
 281
 282                         object IEnumerator.Current {
 283                                 get {
 284                                         return Current;
 285                                 }
 286                         }
 287                 }
 288
 289                 // Properties
 290                 public int Length {
 291                         [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
 292                         get {
 293                                 int length = this.GetLength (0);
 294
 295                                 for (int i = 1; i < this.Rank; i++) {
 296                                         length *= this.GetLength (i);
 297                                 }
 298                                 return length;
 299                         }
 300                 }
 301
 302                 public int Rank {
 303                         [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
 304                         get {
 305                                 return this.GetRank ();
 306                         }
 307                 }
 308
 309                 internal class EmptyInternalEnumerator<T> : IEnumerator<T>
 310                 {
 311                         public static readonly EmptyInternalEnumerator<T> Value = new EmptyInternalEnumerator<T> ();
 312
 313                         public void Dispose ()
 314                         {
 315                                 return;
 316                         }
 317
 318                         public bool MoveNext ()
 319                         {
 320                                 return false;
 321                         }
 322
 323                         public T Current {
 324                                 get {
 325                                         throw new InvalidOperationException ("Enumeration has not started. Call MoveNext");
 326                                 }
 327                         }
 328
 329                         object IEnumerator.Current {
 330                                 get {
 331                                         return Current;
 332                                 }
 333                         }
 334
 335                         void IEnumerator.Reset ()
 336                         {
 337                                 return;
 338                         }
 339                 }
 340
 341                 // InternalCall Methods
 342                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 343                 extern int GetRank ();
 344
 345                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 346                 public extern int GetLength (int dimension);
 347
 348                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
 349                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 350                 public extern int GetLowerBound (int dimension);
 351
 352                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 353                 public extern object GetValue (params int[] indices);
 354
 355                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 356                 public extern void SetValue (object value, params int[] indices);
 357
 358                 // CAUTION! No bounds checking!
 359                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 360                 internal extern object GetValueImpl (int pos);
 361
 362                 // CAUTION! No bounds checking!
 363                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 364                 internal extern void SetValueImpl (object value, int pos);
 365
 366                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 367                 internal extern static bool FastCopy (Array source, int source_idx, Array dest, int dest_idx, int length);
 368
 369                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 370                 internal extern static Array CreateInstanceImpl (Type elementType, int[] lengths, int[] bounds);
 371
 372                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
 373                 public int GetUpperBound (int dimension)
 374                 {
 375                         return GetLowerBound (dimension) + GetLength (dimension) - 1;
 376                 }
 377
 378                 public object GetValue (int index)
 379                 {
 380                         if (Rank != 1)
 381                                 throw new ArgumentException (SR.Arg_RankMultiDimNotSupported);
 382
 383                         var lb  = GetLowerBound (0);
 384                         if (index < lb || index > GetUpperBound (0))
 385                                 throw new IndexOutOfRangeException ("Index has to be between upper and lower bound of the array.");
 386
 387                         if (GetType ().GetElementType ().IsPointer)
 388                                 throw new NotSupportedException ("Type is not supported.");
 389
 390                         return GetValueImpl (index - lb);
 391                 }
 392
 393                 public object GetValue (int index1, int index2)
 394                 {
 395                         int[] ind = {index1, index2};
 396                         return GetValue (ind);
 397                 }
 398
 399                 public object GetValue (int index1, int index2, int index3)
 400                 {
 401                         int[] ind = {index1, index2, index3};
 402                         return GetValue (ind);
 403                 }
 404
 405                 public void SetValue (object value, int index)
 406                 {
 407                         if (Rank != 1)
 408                                 throw new ArgumentException (SR.Arg_RankMultiDimNotSupported);
 409
 410                         var lb  = GetLowerBound (0);
 411                         if (index < lb || index > GetUpperBound (0))
 412                                 throw new IndexOutOfRangeException ("Index has to be >= lower bound and <= upper bound of the array.");
 413
 414                         if (GetType ().GetElementType ().IsPointer)
 415                                 throw new NotSupportedException ("Type is not supported.");
 416
 417                         SetValueImpl (value, index - lb);
 418                 }
 419
 420                 public void SetValue (object value, int index1, int index2)
 421                 {
 422                         int[] ind = {index1, index2};
 423                         SetValue (value, ind);
 424                 }
 425
 426                 public void SetValue (object value, int index1, int index2, int index3)
 427                 {
 428                         int[] ind = {index1, index2, index3};
 429                         SetValue (value, ind);
 430                 }
 431
 432                 internal static Array UnsafeCreateInstance(Type elementType, int[] lengths, int[] lowerBounds)
 433                 {
 434                         return CreateInstance(elementType, lengths, lowerBounds);
 435                 }
 436
 437                 internal static Array UnsafeCreateInstance (Type elementType, int length1, int length2)
 438                 {
 439                         return CreateInstance (elementType, length1, length2);
 440                 }
 441
 442                 internal static Array UnsafeCreateInstance (Type elementType, params int[] lengths)
 443                 {
 444                         return CreateInstance(elementType, lengths);
 445                 }
 446
 447                 public static Array CreateInstance (Type elementType, int length)
 448                 {
 449                         int[] lengths = {length};
 450
 451                         return CreateInstance (elementType, lengths);
 452                 }
 453
 454                 public static Array CreateInstance (Type elementType, int length1, int length2)
 455                 {
 456                         int[] lengths = {length1, length2};
 457
 458                         return CreateInstance (elementType, lengths);
 459                 }
 460
 461                 public static Array CreateInstance (Type elementType, int length1, int length2, int length3)
 462                 {
 463                         int[] lengths = {length1, length2, length3};
 464
 465                         return CreateInstance (elementType, lengths);
 466                 }
 467
 468                 public static Array CreateInstance (Type elementType, params int[] lengths)
 469                 {
 470                         if (elementType == null)
 471                                 throw new ArgumentNullException ("elementType");
 472                         if (lengths == null)
 473                                 throw new ArgumentNullException ("lengths");
 474
 475                         if (lengths.Length > 255)
 476                                 throw new TypeLoadException ();
 477
 478                         int[] bounds = null;
 479
 480                         elementType = elementType.UnderlyingSystemType as RuntimeType;
 481                         if (elementType == null)
 482                                 throw new ArgumentException ("Type must be a type provided by the runtime.", "elementType");
 483                         if (elementType.Equals (typeof (void)))
 484                                 throw new NotSupportedException ("Array type can not be void");
 485                         if (elementType.ContainsGenericParameters)
 486                                 throw new NotSupportedException ("Array type can not be an open generic type");
 487
 488                         return CreateInstanceImpl (elementType, lengths, bounds);
 489                 }
 490
 491                 public static Array CreateInstance (Type elementType, int[] lengths, int [] lowerBounds)
 492                 {
 493                         if (elementType == null)
 494                                 throw new ArgumentNullException ("elementType");
 495                         if (lengths == null)
 496                                 throw new ArgumentNullException ("lengths");
 497                         if (lowerBounds == null)
 498                                 throw new ArgumentNullException ("lowerBounds");
 499
 500                         elementType = elementType.UnderlyingSystemType as RuntimeType;
 501                         if (elementType == null)
 502                                 throw new ArgumentException ("Type must be a type provided by the runtime.", "elementType");
 503                         if (elementType.Equals (typeof (void)))
 504                                 throw new NotSupportedException ("Array type can not be void");
 505                         if (elementType.ContainsGenericParameters)
 506                                 throw new NotSupportedException ("Array type can not be an open generic type");
 507
 508                         if (lengths.Length < 1)
 509                                 throw new ArgumentException ("Arrays must contain >= 1 elements.");
 510
 511                         if (lengths.Length != lowerBounds.Length)
 512                                 throw new ArgumentException ("Arrays must be of same size.");
 513
 514                         for (int j = 0; j < lowerBounds.Length; j ++) {
 515                                 if (lengths [j] < 0)
 516                                         throw new ArgumentOutOfRangeException ("lengths", "Each value has to be >= 0.");
 517                                 if ((long)lowerBounds [j] + (long)lengths [j] > (long)Int32.MaxValue)
 518                                         throw new ArgumentOutOfRangeException ("lengths", "Length + bound must not exceed Int32.MaxValue.");
 519                         }
 520
 521                         if (lengths.Length > 255)
 522                                 throw new TypeLoadException ();
 523
 524                         return CreateInstanceImpl (elementType, lengths, lowerBounds);
 525                 }
 526
 527                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
 528                 public static void Clear (Array array, int index, int length)
 529                 {
 530                         if (array == null)
 531                                 throw new ArgumentNullException ("array");
 532                         if (length < 0)
 533                                 throw new IndexOutOfRangeException ("length < 0");
 534
 535                         int low = array.GetLowerBound (0);
 536                         if (index < low)
 537                                 throw new IndexOutOfRangeException ("index < lower bound");
 538                         index = index - low;
 539
 540                         // re-ordered to avoid possible integer overflow
 541                         if (index > array.Length - length)
 542                                 throw new IndexOutOfRangeException ("index + length > size");
 543
 544                         ClearInternal (array, index, length);
 545                 }
 546
 547                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 548                 static extern void ClearInternal (Array a, int index, int count);
 549
 550                 [ReliabilityContractAttribute (Consistency.MayCorruptInstance, Cer.MayFail)]
 551                 public static void Copy (Array sourceArray, Array destinationArray, int length)
 552                 {
 553                         // need these checks here because we are going to use
 554                         // GetLowerBound() on source and dest.
 555                         if (sourceArray == null)
 556                                 throw new ArgumentNullException ("sourceArray");
 557
 558                         if (destinationArray == null)
 559                                 throw new ArgumentNullException ("destinationArray");
 560
 561                         Copy (sourceArray, sourceArray.GetLowerBound (0), destinationArray,
 562                                 destinationArray.GetLowerBound (0), length);
 563                 }
 564
 565                 [ReliabilityContractAttribute (Consistency.MayCorruptInstance, Cer.MayFail)]
 566                 public static void Copy (Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
 567                 {
 568                         if (sourceArray == null)
 569                                 throw new ArgumentNullException ("sourceArray");
 570
 571                         if (destinationArray == null)
 572                                 throw new ArgumentNullException ("destinationArray");
 573
 574                         if (length < 0)
 575                                 throw new ArgumentOutOfRangeException ("length", "Value has to be >= 0.");
 576
 577                         if (sourceArray.Rank != destinationArray.Rank)
 578                                 throw new RankException(SR.Rank_MultiDimNotSupported);
 579
 580                         if (sourceIndex < 0)
 581                                 throw new ArgumentOutOfRangeException ("sourceIndex", "Value has to be >= 0.");
 582
 583                         if (destinationIndex < 0)
 584                                 throw new ArgumentOutOfRangeException ("destinationIndex", "Value has to be >= 0.");
 585
 586                         if (FastCopy (sourceArray, sourceIndex, destinationArray, destinationIndex, length))
 587                                 return;
 588
 589                         int source_pos = sourceIndex - sourceArray.GetLowerBound (0);
 590                         int dest_pos = destinationIndex - destinationArray.GetLowerBound (0);
 591
 592                         if (dest_pos < 0)
 593                                 throw new ArgumentOutOfRangeException ("destinationIndex", "Index was less than the array's lower bound in the first dimension.");
 594
 595                         // re-ordered to avoid possible integer overflow
 596                         if (source_pos > sourceArray.Length - length)
 597                                 throw new ArgumentException ("length");
 598
 599                         if (dest_pos > destinationArray.Length - length) {
 600                                 throw new ArgumentException ("Destination array was not long enough. Check destIndex and length, and the array's lower bounds", nameof (destinationArray));
 601                         }
 602
 603                         Type src_type = sourceArray.GetType ().GetElementType ();
 604                         Type dst_type = destinationArray.GetType ().GetElementType ();
 605                         var dst_type_vt = dst_type.IsValueType;
 606
 607                         if (!Object.ReferenceEquals (sourceArray, destinationArray) || source_pos > dest_pos) {
 608                                 for (int i = 0; i < length; i++) {
 609                                         Object srcval = sourceArray.GetValueImpl (source_pos + i);
 610
 611                                         if (srcval == null && dst_type_vt)
 612                                                 throw new InvalidCastException ();
 613
 614                                         try {
 615                                                 destinationArray.SetValueImpl (srcval, dest_pos + i);
 616                                         } catch (ArgumentException) {
 617                                                 throw CreateArrayTypeMismatchException ();
 618                                         } catch (InvalidCastException) {
 619                                                 if (CanAssignArrayElement (src_type, dst_type))
 620                                                         throw;
 621                                                 throw CreateArrayTypeMismatchException ();
 622                                         }
 623                                 }
 624                         }
 625                         else {
 626                                 for (int i = length - 1; i >= 0; i--) {
 627                                         Object srcval = sourceArray.GetValueImpl (source_pos + i);
 628
 629                                         try {
 630                                                 destinationArray.SetValueImpl (srcval, dest_pos + i);
 631                                         } catch (ArgumentException) {
 632                                                 throw CreateArrayTypeMismatchException ();
 633                                         } catch {
 634                                                 if (CanAssignArrayElement (src_type, dst_type))
 635                                                         throw;
 636
 637                                                 throw CreateArrayTypeMismatchException ();
 638                                         }
 639                                 }
 640                         }
 641                 }
 642
 643                 static ArrayTypeMismatchException CreateArrayTypeMismatchException ()
 644                 {
 645                         return new ArrayTypeMismatchException ();
 646                 }
 647
 648                 static bool CanAssignArrayElement (Type source, Type target)
 649                 {
 650                         if (source.IsValueType)
 651                                 return source.IsAssignableFrom (target);
 652
 653                         if (source.IsInterface)
 654                                 return !target.IsValueType;
 655
 656                         if (target.IsInterface)
 657                                 return !source.IsValueType;
 658
 659                         return source.IsAssignableFrom (target) || target.IsAssignableFrom (source);
 660                 }
 661
 662                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
 663                 //
 664                 // The constrained copy should guarantee that if there is an exception thrown
 665                 // during the copy, the destination array remains unchanged.
 666                 // This is related to System.Runtime.Reliability.CER
 667                 public static void ConstrainedCopy (Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
 668                 {
 669                         Copy (sourceArray, sourceIndex, destinationArray, destinationIndex, length);
 670                 }
 671
 672                 public static T[] Empty<T>()
 673                 {
 674                         return EmptyArray<T>.Value;
 675                 }
 676
 677                 public void Initialize()
 678                 {
 679                         return;
 680                 }
 681
 682                 static int IndexOfImpl<T>(T[] array, T value, int startIndex, int count)
 683                 {
 684                         return EqualityComparer<T>.Default.IndexOf (array, value, startIndex, count);
 685                 }
 686
 687                 static int LastIndexOfImpl<T>(T[] array, T value, int startIndex, int count)
 688                 {
 689                         return EqualityComparer<T>.Default.LastIndexOf (array, value, startIndex, count);
 690                 }
 691
 692                 static void SortImpl (Array keys, Array items, int index, int length, IComparer comparer)
 693                 {
 694                         Object[] objKeys = keys as Object[];
 695                         Object[] objItems = null;
 696                         if (objKeys != null)
 697                                 objItems = items as Object[];
 698
 699                         if (objKeys != null && (items == null || objItems != null)) {
 700                                 SorterObjectArray sorter = new SorterObjectArray(objKeys, objItems, comparer);
 701                                 sorter.Sort(index, length);
 702                         } else {
 703                                 SorterGenericArray sorter = new SorterGenericArray(keys, items, comparer);
 704                                 sorter.Sort(index, length);
 705                         }
 706                 }
 707
 708                 #region Unsafe array operations
 709
 710                 //
 711                 // Loads array index with no safety checks (JIT intristics)
 712                 //
 713                 internal static T UnsafeLoad<T> (T[] array, int index) {
 714                         return array [index];
 715                 }
 716
 717                 //
 718                 // Stores values at specified array index with no safety checks (JIT intristics)
 719                 //
 720                 internal static void UnsafeStore<T> (T[] array, int index, T value) {
 721                         array [index] = value;
 722                 }
 723
 724                 //
 725                 // Moved value from instance into target of different type with no checks (JIT intristics)
 726                 //
 727                 // Restrictions:
 728                 //
 729                 // S and R must either:
 730                 //       both be blitable valuetypes
 731                 //       both be reference types (IOW, an unsafe cast)
 732                 // S and R cannot be float or double
 733                 // S and R must either:
 734                 //       both be a struct
 735                 //       both be a scalar
 736                 // S and R must either:
 737                 //       be of same size
 738                 //       both be a scalar of size <= 4
 739                 //
 740                 internal static R UnsafeMov<S,R> (S instance) {
 741                         return (R)(object) instance;
 742                 }
 743
 744                 #endregion
 745
 746                 internal sealed class FunctorComparer<T> : IComparer<T> {
 747                         Comparison<T> comparison;
 748
 749                         public FunctorComparer(Comparison<T> comparison) {
 750                                 this.comparison = comparison;
 751                         }
 752
 753                         public int Compare(T x, T y) {
 754                                 return comparison(x, y);
 755                         }
 756                 }
 757
 758                 partial class ArrayEnumerator
 759                 {
 760                         public Object Current {
 761                                 get {
 762                                         if (_index < 0) throw new InvalidOperationException (SR.InvalidOperation_EnumNotStarted);
 763                                         if (_index >= _endIndex) throw new InvalidOperationException (SR.InvalidOperation_EnumEnded);
 764                                         if (_index == 0 && _array.GetType ().GetElementType ().IsPointer) throw new NotSupportedException ("Type is not supported.");
 765                                         return _array.GetValueImpl(_index);
 766                                 }
 767                         }
 768                 }
 769         }
 770 }