Remove usage of ArrayT<T>

stephentoub · stephentoub · commit 54ec4d0ad3c1 · 2015-06-10T22:27:38.000-04:00
ArrayT&lt;T&gt; was a temporary workaround for some performance issues during the implementation of .NET Native.  Those performance issues have been fixed and the workaround is no longer needed.

This commit removes all usage of ArrayT&lt;T&gt; from the code currently on GitHub. The ArrayT.cs file itself is left to avoid breaking any libraries that haven't yet been ported to GitHub when the mirror moves these changes back internally.
diff --git a/src/Common/src/System/Collections/Generic/EnumerableHelpers.cs b/src/Common/src/System/Collections/Generic/EnumerableHelpers.cs
@@ -72,7 +72,7 @@ internal static T[] ToArray<T>(IEnumerable<T> source, out int length)
                             newLength = count + 1;
                         }
 
-                        arr = ArrayT<T>.Resize(arr, newLength, count);
+                        Array.Resize(ref arr, newLength);
                     }
                     arr[count++] = item;
                 }
diff --git a/src/Common/src/System/Collections/Generic/LowLevelList.cs b/src/Common/src/System/Collections/Generic/LowLevelList.cs
@@ -137,14 +137,9 @@ public int Capacity
                 {
                     if (value > 0)
                     {
-#if TYPE_LOADER_IMPLEMENTATION
                         T[] newItems = new T[value];
-                        for (int i = 0; i < _size; i++)
-                            newItems[i] = _items[i];
+                        Array.Copy(_items, 0, newItems, 0, _size);
                         _items = newItems;
-#else
-                        _items = ArrayT<T>.Resize(_items, value, _size);
-#endif
                     }
                     else
                     {
@@ -237,7 +232,7 @@ public void Clear()
         {
             if (_size > 0)
             {
-                ArrayT<T>.Clear(_items, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
+                Array.Clear(_items, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
                 _size = 0;
             }
             _version++;
@@ -279,13 +274,13 @@ public void CopyTo(int index, T[] array, int arrayIndex, int count)
             Contract.EndContractBlock();
 
             // Delegate rest of error checking to Array.Copy.
-            ArrayT<T>.Copy(_items, index, array, arrayIndex, count);
+            Array.Copy(_items, index, array, arrayIndex, count);
         }
 
         public void CopyTo(T[] array, int arrayIndex)
         {
             // Delegate rest of error checking to Array.Copy.
-            ArrayT<T>.Copy(_items, 0, array, arrayIndex, _size);
+            Array.Copy(_items, 0, array, arrayIndex, _size);
         }
 
         // Returns the index of the first occurrence of a given value in a range of
@@ -338,7 +333,7 @@ public void Insert(int index, T item)
             if (_size == _items.Length) EnsureCapacity(_size + 1);
             if (index < _size)
             {
-                ArrayT<T>.Copy(_items, index, _items, index + 1, _size - index);
+                Array.Copy(_items, index, _items, index + 1, _size - index);
             }
             _items[index] = item;
             _size++;
@@ -372,22 +367,22 @@ public void InsertRange(int index, IEnumerable<T> collection)
                     EnsureCapacity(_size + count);
                     if (index < _size)
                     {
-                        ArrayT<T>.Copy(_items, index, _items, index + count, _size - index);
+                        Array.Copy(_items, index, _items, index + count, _size - index);
                     }
 
                     // If we're inserting a List into itself, we want to be able to deal with that.
                     if (this == c)
                     {
                         // Copy first part of _items to insert location
-                        ArrayT<T>.Copy(_items, 0, _items, index, index);
+                        Array.Copy(_items, 0, _items, index, index);
                         // Copy last part of _items back to inserted location
-                        ArrayT<T>.Copy(_items, index + count, _items, index * 2, _size - index);
+                        Array.Copy(_items, index + count, _items, index * 2, _size - index);
                     }
                     else
                     {
                         T[] itemsToInsert = new T[count];
                         c.CopyTo(itemsToInsert, 0);
-                        ArrayT<T>.Copy(itemsToInsert, 0, _items, index, count);
+                        Array.Copy(itemsToInsert, 0, _items, index, count);
                     }
                     _size += count;
                 }
@@ -451,7 +446,7 @@ public int RemoveAll(Predicate<T> match)
                 }
             }
 
-            ArrayT<T>.Clear(_items, freeIndex, _size - freeIndex);
+            Array.Clear(_items, freeIndex, _size - freeIndex);
             int result = _size - freeIndex;
             _size = freeIndex;
             _version++;
@@ -471,7 +466,7 @@ public void RemoveAt(int index)
             _size--;
             if (index < _size)
             {
-                ArrayT<T>.Copy(_items, index + 1, _items, index, _size - index);
+                Array.Copy(_items, index + 1, _items, index, _size - index);
             }
             _items[_size] = default(T);
             _version++;
@@ -485,7 +480,7 @@ public T[] ToArray()
             Contract.Ensures(Contract.Result<T[]>().Length == Count);
 
             T[] array = new T[_size];
-            ArrayT<T>.Copy(_items, 0, array, 0, _size);
+            Array.Copy(_items, 0, array, 0, _size);
             return array;
         }
 #endif
diff --git a/src/System.Collections.Concurrent/src/System.Collections.Concurrent.csproj b/src/System.Collections.Concurrent/src/System.Collections.Concurrent.csproj
@@ -29,11 +29,6 @@
     <Compile Include="System\Collections\Concurrent\PartitionerStatic.cs" />
     <Compile Include="System\Collections\Concurrent\PlatformHelper.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <Compile Include="$(CommonPath)\System\ArrayT.cs">
-      <Link>Common\System\ArrayT.cs</Link>
-    </Compile>
-  </ItemGroup>
   <ItemGroup>
     <None Include="project.json" />
   </ItemGroup>
diff --git a/src/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs b/src/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs
@@ -1685,7 +1685,8 @@ private void GrowTable(Tables tables)
                 // Add more locks
                 if (_growLockArray && tables._locks.Length < MAX_LOCK_NUMBER)
                 {
-                    newLocks = ArrayT<object>.Resize(tables._locks, tables._locks.Length * 2, tables._locks.Length);
+                    newLocks = new object[tables._locks.Length * 2];
+                    Array.Copy(tables._locks, 0, newLocks, 0, tables._locks.Length);
                     for (int i = tables._locks.Length; i < newLocks.Length; i++)
                     {
                         newLocks[i] = new object();
diff --git a/src/System.Collections.Concurrent/src/System/Collections/Concurrent/PartitionerStatic.cs b/src/System.Collections.Concurrent/src/System/Collections/Concurrent/PartitionerStatic.cs
@@ -665,7 +665,7 @@ private void TryCopyFromFillBuffer(KeyValuePair<long, TSource>[] destArray,
                     {
                         // adjust index and do the actual copy
                         actualNumElementsGrabbed = (endPos < _fillBufferSize) ? endPos : _fillBufferSize - beginPos;
-                        ArrayT<KeyValuePair<long, TSource>>.Copy(fillBufferLocalRef, beginPos, destArray, 0, actualNumElementsGrabbed);
+                        Array.Copy(fillBufferLocalRef, beginPos, destArray, 0, actualNumElementsGrabbed);
                     }
 
                     // let the record show we are no longer accessing the buffer
diff --git a/src/System.Collections/src/System.Collections.csproj b/src/System.Collections/src/System.Collections.csproj
@@ -42,9 +42,6 @@
     <Compile Include="System\Collections\StructuralComparisons.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="$(CommonPath)\System\ArrayT.cs">
-      <Link>Common\System\ArrayT.cs</Link>
-    </Compile>
     <Compile Include="$(CommonPath)\System\Collections\HashHelpers.cs">
       <Link>Common\System\Collections\HashHelpers.cs</Link>
     </Compile>
diff --git a/src/System.Collections/src/System/Collections/Generic/HashSet.cs b/src/System.Collections/src/System/Collections/Generic/HashSet.cs
@@ -157,8 +157,8 @@ public void Clear()
 
                 // clear the elements so that the gc can reclaim the references.
                 // clear only up to _lastIndex for _slots 
-                ArrayT<Slot>.Clear(_slots, 0, _lastIndex);
-                ArrayT<int>.Clear(_buckets, 0, _buckets.Length);
+                Array.Clear(_slots, 0, _lastIndex);
+                Array.Clear(_buckets, 0, _buckets.Length);
                 _lastIndex = 0;
                 _count = 0;
                 _freeList = -1;
@@ -919,11 +919,11 @@ private void SetCapacity(int newSize, bool forceNewHashCodes)
 
             Debug.Assert(_buckets != null, "SetCapacity called on a set with no elements");
 
-            Slot[] newSlots;
-            if (_slots == null)
-                newSlots = new Slot[newSize];
-            else
-                newSlots = ArrayT<Slot>.Resize(_slots, newSize, _lastIndex);
+            Slot[] newSlots = new Slot[newSize];
+            if (_slots != null)
+            {
+                Array.Copy(_slots, 0, newSlots, 0, _lastIndex);
+            }
 
             if (forceNewHashCodes)
             {
diff --git a/src/System.Collections/src/System/Collections/Generic/Queue.cs b/src/System.Collections/src/System/Collections/Generic/Queue.cs
@@ -102,11 +102,11 @@ Object System.Collections.ICollection.SyncRoot
         public void Clear()
         {
             if (_head < _tail)
-                ArrayT<T>.Clear(_array, _head, _size);
+                Array.Clear(_array, _head, _size);
             else
             {
-                ArrayT<T>.Clear(_array, _head, _array.Length - _head);
-                ArrayT<T>.Clear(_array, 0, _tail);
+                Array.Clear(_array, _head, _array.Length - _head);
+                Array.Clear(_array, 0, _tail);
             }
 
             _head = 0;
@@ -141,11 +141,11 @@ public void CopyTo(T[] array, int arrayIndex)
             if (numToCopy == 0) return;
 
             int firstPart = (_array.Length - _head < numToCopy) ? _array.Length - _head : numToCopy;
-            ArrayT<T>.Copy(_array, _head, array, arrayIndex, firstPart);
+            Array.Copy(_array, _head, array, arrayIndex, firstPart);
             numToCopy -= firstPart;
             if (numToCopy > 0)
             {
-                ArrayT<T>.Copy(_array, 0, array, arrayIndex + _array.Length - _head, numToCopy);
+                Array.Copy(_array, 0, array, arrayIndex + _array.Length - _head, numToCopy);
             }
         }
 
@@ -313,12 +313,12 @@ public T[] ToArray()
 
             if (_head < _tail)
             {
-                ArrayT<T>.Copy(_array, _head, arr, 0, _size);
+                Array.Copy(_array, _head, arr, 0, _size);
             }
             else
             {
-                ArrayT<T>.Copy(_array, _head, arr, 0, _array.Length - _head);
-                ArrayT<T>.Copy(_array, 0, arr, _array.Length - _head, _tail);
+                Array.Copy(_array, _head, arr, 0, _array.Length - _head);
+                Array.Copy(_array, 0, arr, _array.Length - _head, _tail);
             }
 
             return arr;
@@ -334,12 +334,12 @@ private void SetCapacity(int capacity)
             {
                 if (_head < _tail)
                 {
-                    ArrayT<T>.Copy(_array, _head, newarray, 0, _size);
+                    Array.Copy(_array, _head, newarray, 0, _size);
                 }
                 else
                 {
-                    ArrayT<T>.Copy(_array, _head, newarray, 0, _array.Length - _head);
-                    ArrayT<T>.Copy(_array, 0, newarray, _array.Length - _head, _tail);
+                    Array.Copy(_array, _head, newarray, 0, _array.Length - _head);
+                    Array.Copy(_array, 0, newarray, _array.Length - _head, _tail);
                 }
             }
 
diff --git a/src/System.Collections/src/System/Collections/Generic/Stack.cs b/src/System.Collections/src/System/Collections/Generic/Stack.cs
@@ -86,7 +86,7 @@ Object System.Collections.ICollection.SyncRoot
         /// <include file='doc\Stack.uex' path='docs/doc[@for="Stack.Clear"]/*' />
         public void Clear()
         {
-            ArrayT<T>.Clear(_array, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
+            Array.Clear(_array, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
             _size = 0;
             _version++;
         }
@@ -141,7 +141,7 @@ public void CopyTo(T[] array, int arrayIndex)
             else
             {
                 // Legacy fallback in case we ever end up copying within the same array.
-                ArrayT<T>.Copy(_array, 0, array, arrayIndex, _size);
+                Array.Copy(_array, 0, array, arrayIndex, _size);
                 Array.Reverse(array, arrayIndex, _size);
             }
         }
@@ -208,8 +208,7 @@ public void TrimExcess()
             int threshold = (int)(((double)_array.Length) * 0.9);
             if (_size < threshold)
             {
-                T[] newarray = ArrayT<T>.Resize(_array, _size, _size);
-                _array = newarray;
+                Array.Resize(ref _array, _size);
                 _version++;
             }
         }
@@ -244,8 +243,7 @@ public void Push(T item)
         {
             if (_size == _array.Length)
             {
-                T[] newArray = ArrayT<T>.Resize(_array, (_array.Length == 0) ? DefaultCapacity : 2 * _array.Length, _size);
-                _array = newArray;
+                Array.Resize(ref _array, (_array.Length == 0) ? DefaultCapacity : 2 * _array.Length);
             }
             _array[_size++] = item;
             _version++;
diff --git a/src/System.Linq.Parallel/src/System.Linq.Parallel.csproj b/src/System.Linq.Parallel/src/System.Linq.Parallel.csproj
@@ -158,9 +158,6 @@
   </ItemGroup>
   <!-- Common or Common-branched source files -->
   <ItemGroup>
-    <Compile Include="$(CommonPath)\System\ArrayT.cs">
-      <Link>Common\System\ArrayT.cs</Link>
-    </Compile>
   </ItemGroup>
   <!-- Resource files -->
   <ItemGroup>
diff --git a/src/System.Linq.Parallel/src/System/Linq/Parallel/Helpers.cs b/src/System.Linq.Parallel/src/System/Linq/Parallel/Helpers.cs
@@ -114,7 +114,8 @@ void Resize()
         {
             int newSize = checked(_count * 2 + 1);
             int[] newBuckets = new int[newSize];
-            Slot[] newSlots = ArrayT<Slot>.Resize(_slots, newSize, _count);
+            Slot[] newSlots = new Slot[newSize];
+            Array.Copy(_slots, 0, newSlots, 0, _count);
             for (int i = 0; i < _count; i++)
             {
                 int bucket = newSlots[i].hashCode % newSize;
diff --git a/src/System.Linq/src/System.Linq.csproj b/src/System.Linq/src/System.Linq.csproj
@@ -16,9 +16,6 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="$(CommonPath)\System\ArrayT.cs">
-      <Link>Common\System\ArrayT.cs</Link>
-    </Compile>
     <Compile Include="$(CommonPath)\System\NotImplemented.cs">
       <Link>Common\System\NotImplemented.cs</Link>
     </Compile>
diff --git a/src/System.Linq/src/System/Linq/Enumerable.cs b/src/System.Linq/src/System/Linq/Enumerable.cs
@@ -2715,7 +2715,7 @@ bool ICollection<TElement>.Contains(TElement item)
 
         void ICollection<TElement>.CopyTo(TElement[] array, int arrayIndex)
         {
-            ArrayT<TElement>.Copy(elements, 0, array, arrayIndex, count);
+            Array.Copy(elements, 0, array, arrayIndex, count);
         }
 
         bool ICollection<TElement>.Remove(TElement item)
@@ -2845,7 +2845,8 @@ private void Resize()
         {
             int newSize = checked(_count * 2 + 1);
             int[] newBuckets = new int[newSize];
-            Slot[] newSlots = ArrayT<Slot>.Resize(_slots, newSize, _count);
+            Slot[] newSlots = new Slot[newSize];
+            Array.Copy(_slots, 0, newSlots, 0, _count);
             for (int i = 0; i < _count; i++)
             {
                 int bucket = newSlots[i].hashCode % newSize;
@@ -3103,8 +3104,7 @@ internal Buffer(IEnumerable<TElement> source)
                     }
                     else if (items.Length == count)
                     {
-                        TElement[] newItems = ArrayT<TElement>.Resize(items, checked(count * 2), count);
-                        items = newItems;
+                        Array.Resize(ref items, checked(count * 2));
                     }
                     items[count] = item;
                     count++;
@@ -3119,7 +3119,9 @@ internal TElement[] ToArray()
             if (count == 0) return new TElement[0];
             if (items.Length == count) return items;
 
-            return ArrayT<TElement>.Resize(items, count, count);
+            var arr = new TElement[count];
+            Array.Copy(items, 0, arr, 0, count);
+            return arr;
         }
     }
 
diff --git a/src/System.Private.Uri/src/System.Private.Uri.CoreCLR.csproj b/src/System.Private.Uri/src/System.Private.Uri.CoreCLR.csproj
@@ -25,9 +25,6 @@
     <Compile Include="$(CommonPath)\System\Diagnostics\Debug.cs">
       <Link>Common\System\Diagnostics\Debug.cs</Link>
     </Compile>
-    <Compile Include="$(CommonPath)\System\ArrayT.cs">
-      <Link>Common\System\ArrayT.cs</Link>
-    </Compile>
     <Compile Include="$(CommonPath)\System\Collections\Generic\LowLevelDictionary.cs">
       <Link>Common\System\Collections\Generic\LowLevelDictionary.cs</Link>
     </Compile>
diff --git a/src/System.Runtime.Extensions/src/System.Runtime.Extensions.CoreCLR.csproj b/src/System.Runtime.Extensions/src/System.Runtime.Extensions.CoreCLR.csproj
@@ -30,9 +30,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Include="$(CommonPath)\System\ArrayT.cs">
-      <Link>System\ArrayT.cs</Link>
-    </Compile>
     <Compile Include="$(CommonPath)\System\Collections\Generic\LowLevelDictionary.cs">
       <Link>System\Collections\Generic\LowLevelDictionary.cs</Link>
     </Compile>
diff --git a/src/System.Runtime.Extensions/src/System/Net/WebUtility.cs b/src/System.Runtime.Extensions/src/System/Net/WebUtility.cs
@@ -517,7 +517,7 @@ private static byte[] UrlDecodeInternal(byte[] bytes, int offset, int count)
 
             if (decodedBytesCount < decodedBytes.Length)
             {
-                decodedBytes = ArrayT<byte>.Resize(decodedBytes, decodedBytesCount, decodedBytesCount);
+                Array.Resize(ref decodedBytes, decodedBytesCount);
             }
 
             return decodedBytes;
diff --git a/src/System.Security.Cryptography.Encoding/src/System.Security.Cryptography.Encoding.csproj b/src/System.Security.Cryptography.Encoding/src/System.Security.Cryptography.Encoding.csproj
@@ -28,9 +28,6 @@
     <Compile Include="System\Security\Cryptography\OidGroup.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="$(CommonPath)\System\ArrayT.cs">
-      <Link>Common\System\ArrayT.cs</Link>
-    </Compile>
     <Compile Include="$(CommonPath)\System\Collections\Generic\LowLevelList.cs">
       <Link>Common\System\Collections\Generic\LowLevelList.cs</Link>
     </Compile>
diff --git a/src/System.Security.Cryptography.RSA/src/System.Security.Cryptography.RSA.csproj b/src/System.Security.Cryptography.RSA/src/System.Security.Cryptography.RSA.csproj
@@ -38,9 +38,6 @@
     <Compile Include="System\Security\Cryptography\RSAParameters.cs" />
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetsWindows)' == 'true' ">
-    <Compile Include="$(CommonPath)\System\ArrayT.cs">
-      <Link>Common\System\ArrayT.cs</Link>
-    </Compile>
     <Compile Include="$(CommonPath)\System\Collections\Generic\LowLevelList.cs">
       <Link>Common\System\Collections\Generic\LowLevelList.cs</Link>
     </Compile>
diff --git a/src/System.Security.Cryptography.X509Certificates/src/System.Security.Cryptography.X509Certificates.csproj b/src/System.Security.Cryptography.X509Certificates/src/System.Security.Cryptography.X509Certificates.csproj
diff --git a/src/System.Xml.XPath.XDocument/src/System.Xml.XPath.XDocument.csproj b/src/System.Xml.XPath.XDocument/src/System.Xml.XPath.XDocument.csproj
diff --git a/src/System.Xml.XPath.XmlDocument/src/System.Xml.XPath.XmlDocument.csproj b/src/System.Xml.XPath.XmlDocument/src/System.Xml.XPath.XmlDocument.csproj

Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ internal static T[] ToArray<T>(IEnumerable<T> source, out int length)`
`72`	`72`	`newLength = count + 1;`
`73`	`73`	`}`
`74`	`74`
`75`		`- arr = ArrayT<T>.Resize(arr, newLength, count);`
	`75`	`+ Array.Resize(ref arr, newLength);`
`76`	`76`	`}`
`77`	`77`	`arr[count++] = item;`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -137,14 +137,9 @@ public int Capacity`
`137`	`137`	`{`
`138`	`138`	`if (value > 0)`
`139`	`139`	`{`
`140`		`-#if TYPE_LOADER_IMPLEMENTATION`
`141`	`140`	`T[] newItems = new T[value];`
`142`		`- for (int i = 0; i < _size; i++)`
`143`		`- newItems[i] = _items[i];`
	`141`	`+ Array.Copy(_items, 0, newItems, 0, _size);`
`144`	`142`	`_items = newItems;`
`145`		`-#else`
`146`		`- _items = ArrayT<T>.Resize(_items, value, _size);`
`147`		`-#endif`
`148`	`143`	`}`
`149`	`144`	`else`
`150`	`145`	`{`
`@@ -237,7 +232,7 @@ public void Clear()`
`237`	`232`	`{`
`238`	`233`	`if (_size > 0)`
`239`	`234`	`{`
`240`		`- ArrayT<T>.Clear(_items, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.`
	`235`	`+ Array.Clear(_items, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.`
`241`	`236`	`_size = 0;`
`242`	`237`	`}`
`243`	`238`	`_version++;`
`@@ -279,13 +274,13 @@ public void CopyTo(int index, T[] array, int arrayIndex, int count)`
`279`	`274`	`Contract.EndContractBlock();`
`280`	`275`
`281`	`276`	`// Delegate rest of error checking to Array.Copy.`
`282`		`- ArrayT<T>.Copy(_items, index, array, arrayIndex, count);`
	`277`	`+ Array.Copy(_items, index, array, arrayIndex, count);`
`283`	`278`	`}`
`284`	`279`
`285`	`280`	`public void CopyTo(T[] array, int arrayIndex)`
`286`	`281`	`{`
`287`	`282`	`// Delegate rest of error checking to Array.Copy.`
`288`		`- ArrayT<T>.Copy(_items, 0, array, arrayIndex, _size);`
	`283`	`+ Array.Copy(_items, 0, array, arrayIndex, _size);`
`289`	`284`	`}`
`290`	`285`
`291`	`286`	`// Returns the index of the first occurrence of a given value in a range of`
`@@ -338,7 +333,7 @@ public void Insert(int index, T item)`
`338`	`333`	`if (_size == _items.Length) EnsureCapacity(_size + 1);`
`339`	`334`	`if (index < _size)`
`340`	`335`	`{`
`341`		`- ArrayT<T>.Copy(_items, index, _items, index + 1, _size - index);`
	`336`	`+ Array.Copy(_items, index, _items, index + 1, _size - index);`
`342`	`337`	`}`
`343`	`338`	`_items[index] = item;`
`344`	`339`	`_size++;`
`@@ -372,22 +367,22 @@ public void InsertRange(int index, IEnumerable<T> collection)`
`372`	`367`	`EnsureCapacity(_size + count);`
`373`	`368`	`if (index < _size)`
`374`	`369`	`{`
`375`		`- ArrayT<T>.Copy(_items, index, _items, index + count, _size - index);`
	`370`	`+ Array.Copy(_items, index, _items, index + count, _size - index);`
`376`	`371`	`}`
`377`	`372`
`378`	`373`	`// If we're inserting a List into itself, we want to be able to deal with that.`
`379`	`374`	`if (this == c)`
`380`	`375`	`{`
`381`	`376`	`// Copy first part of _items to insert location`
`382`		`- ArrayT<T>.Copy(_items, 0, _items, index, index);`
	`377`	`+ Array.Copy(_items, 0, _items, index, index);`
`383`	`378`	`// Copy last part of _items back to inserted location`
`384`		`- ArrayT<T>.Copy(_items, index + count, _items, index * 2, _size - index);`
	`379`	`+ Array.Copy(_items, index + count, _items, index * 2, _size - index);`
`385`	`380`	`}`
`386`	`381`	`else`
`387`	`382`	`{`
`388`	`383`	`T[] itemsToInsert = new T[count];`
`389`	`384`	`c.CopyTo(itemsToInsert, 0);`
`390`		`- ArrayT<T>.Copy(itemsToInsert, 0, _items, index, count);`
	`385`	`+ Array.Copy(itemsToInsert, 0, _items, index, count);`
`391`	`386`	`}`
`392`	`387`	`_size += count;`
`393`	`388`	`}`
`@@ -451,7 +446,7 @@ public int RemoveAll(Predicate<T> match)`
`451`	`446`	`}`
`452`	`447`	`}`
`453`	`448`
`454`		`- ArrayT<T>.Clear(_items, freeIndex, _size - freeIndex);`
	`449`	`+ Array.Clear(_items, freeIndex, _size - freeIndex);`
`455`	`450`	`int result = _size - freeIndex;`
`456`	`451`	`_size = freeIndex;`
`457`	`452`	`_version++;`
`@@ -471,7 +466,7 @@ public void RemoveAt(int index)`
`471`	`466`	`_size--;`
`472`	`467`	`if (index < _size)`
`473`	`468`	`{`
`474`		`- ArrayT<T>.Copy(_items, index + 1, _items, index, _size - index);`
	`469`	`+ Array.Copy(_items, index + 1, _items, index, _size - index);`
`475`	`470`	`}`
`476`	`471`	`_items[_size] = default(T);`
`477`	`472`	`_version++;`
`@@ -485,7 +480,7 @@ public T[] ToArray()`
`485`	`480`	`Contract.Ensures(Contract.Result<T[]>().Length == Count);`
`486`	`481`
`487`	`482`	`T[] array = new T[_size];`
`488`		`- ArrayT<T>.Copy(_items, 0, array, 0, _size);`
	`483`	`+ Array.Copy(_items, 0, array, 0, _size);`
`489`	`484`	`return array;`
`490`	`485`	`}`
`491`	`486`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -1685,7 +1685,8 @@ private void GrowTable(Tables tables)`
`1685`	`1685`	`// Add more locks`
`1686`	`1686`	`if (_growLockArray && tables._locks.Length < MAX_LOCK_NUMBER)`
`1687`	`1687`	`{`
`1688`		`- newLocks = ArrayT<object>.Resize(tables._locks, tables._locks.Length * 2, tables._locks.Length);`
	`1688`	`+ newLocks = new object[tables._locks.Length * 2];`
	`1689`	`+ Array.Copy(tables._locks, 0, newLocks, 0, tables._locks.Length);`
`1689`	`1690`	`for (int i = tables._locks.Length; i < newLocks.Length; i++)`
`1690`	`1691`	`{`
`1691`	`1692`	`newLocks[i] = new object();`
Original file line number	Diff line number	Diff line change
`@@ -665,7 +665,7 @@ private void TryCopyFromFillBuffer(KeyValuePair<long, TSource>[] destArray,`
`665`	`665`	`{`
`666`	`666`	`// adjust index and do the actual copy`
`667`	`667`	`actualNumElementsGrabbed = (endPos < _fillBufferSize) ? endPos : _fillBufferSize - beginPos;`
`668`		`- ArrayT<KeyValuePair<long, TSource>>.Copy(fillBufferLocalRef, beginPos, destArray, 0, actualNumElementsGrabbed);`
	`668`	`+ Array.Copy(fillBufferLocalRef, beginPos, destArray, 0, actualNumElementsGrabbed);`
`669`	`669`	`}`
`670`	`670`
`671`	`671`	`// let the record show we are no longer accessing the buffer`
Original file line number	Diff line number	Diff line change
`@@ -102,11 +102,11 @@ Object System.Collections.ICollection.SyncRoot`
`102`	`102`	`public void Clear()`
`103`	`103`	`{`
`104`	`104`	`if (_head < _tail)`
`105`		`- ArrayT<T>.Clear(_array, _head, _size);`
	`105`	`+ Array.Clear(_array, _head, _size);`
`106`	`106`	`else`
`107`	`107`	`{`
`108`		`- ArrayT<T>.Clear(_array, _head, _array.Length - _head);`
`109`		`- ArrayT<T>.Clear(_array, 0, _tail);`
	`108`	`+ Array.Clear(_array, _head, _array.Length - _head);`
	`109`	`+ Array.Clear(_array, 0, _tail);`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`_head = 0;`
`@@ -141,11 +141,11 @@ public void CopyTo(T[] array, int arrayIndex)`
`141`	`141`	`if (numToCopy == 0) return;`
`142`	`142`
`143`	`143`	`int firstPart = (_array.Length - _head < numToCopy) ? _array.Length - _head : numToCopy;`
`144`		`- ArrayT<T>.Copy(_array, _head, array, arrayIndex, firstPart);`
	`144`	`+ Array.Copy(_array, _head, array, arrayIndex, firstPart);`
`145`	`145`	`numToCopy -= firstPart;`
`146`	`146`	`if (numToCopy > 0)`
`147`	`147`	`{`
`148`		`- ArrayT<T>.Copy(_array, 0, array, arrayIndex + _array.Length - _head, numToCopy);`
	`148`	`+ Array.Copy(_array, 0, array, arrayIndex + _array.Length - _head, numToCopy);`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`@@ -313,12 +313,12 @@ public T[] ToArray()`
`313`	`313`
`314`	`314`	`if (_head < _tail)`
`315`	`315`	`{`
`316`		`- ArrayT<T>.Copy(_array, _head, arr, 0, _size);`
	`316`	`+ Array.Copy(_array, _head, arr, 0, _size);`
`317`	`317`	`}`
`318`	`318`	`else`
`319`	`319`	`{`
`320`		`- ArrayT<T>.Copy(_array, _head, arr, 0, _array.Length - _head);`
`321`		`- ArrayT<T>.Copy(_array, 0, arr, _array.Length - _head, _tail);`
	`320`	`+ Array.Copy(_array, _head, arr, 0, _array.Length - _head);`
	`321`	`+ Array.Copy(_array, 0, arr, _array.Length - _head, _tail);`
`322`	`322`	`}`
`323`	`323`
`324`	`324`	`return arr;`
`@@ -334,12 +334,12 @@ private void SetCapacity(int capacity)`
`334`	`334`	`{`
`335`	`335`	`if (_head < _tail)`
`336`	`336`	`{`
`337`		`- ArrayT<T>.Copy(_array, _head, newarray, 0, _size);`
	`337`	`+ Array.Copy(_array, _head, newarray, 0, _size);`
`338`	`338`	`}`
`339`	`339`	`else`
`340`	`340`	`{`
`341`		`- ArrayT<T>.Copy(_array, _head, newarray, 0, _array.Length - _head);`
`342`		`- ArrayT<T>.Copy(_array, 0, newarray, _array.Length - _head, _tail);`
	`341`	`+ Array.Copy(_array, _head, newarray, 0, _array.Length - _head);`
	`342`	`+ Array.Copy(_array, 0, newarray, _array.Length - _head, _tail);`
`343`	`343`	`}`
`344`	`344`	`}`
`345`	`345`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ Object System.Collections.ICollection.SyncRoot`
`86`	`86`	`/// <include file='doc\Stack.uex' path='docs/doc[@for="Stack.Clear"]/*' />`
`87`	`87`	`public void Clear()`
`88`	`88`	`{`
`89`		`- ArrayT<T>.Clear(_array, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.`
	`89`	`+ Array.Clear(_array, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.`
`90`	`90`	`_size = 0;`
`91`	`91`	`_version++;`
`92`	`92`	`}`
`@@ -141,7 +141,7 @@ public void CopyTo(T[] array, int arrayIndex)`
`141`	`141`	`else`
`142`	`142`	`{`
`143`	`143`	`// Legacy fallback in case we ever end up copying within the same array.`
`144`		`- ArrayT<T>.Copy(_array, 0, array, arrayIndex, _size);`
	`144`	`+ Array.Copy(_array, 0, array, arrayIndex, _size);`
`145`	`145`	`Array.Reverse(array, arrayIndex, _size);`
`146`	`146`	`}`
`147`	`147`	`}`
`@@ -208,8 +208,7 @@ public void TrimExcess()`
`208`	`208`	`int threshold = (int)(((double)_array.Length) * 0.9);`
`209`	`209`	`if (_size < threshold)`
`210`	`210`	`{`
`211`		`- T[] newarray = ArrayT<T>.Resize(_array, _size, _size);`
`212`		`- _array = newarray;`
	`211`	`+ Array.Resize(ref _array, _size);`
`213`	`212`	`_version++;`
`214`	`213`	`}`
`215`	`214`	`}`
`@@ -244,8 +243,7 @@ public void Push(T item)`
`244`	`243`	`{`
`245`	`244`	`if (_size == _array.Length)`
`246`	`245`	`{`
`247`		`- T[] newArray = ArrayT<T>.Resize(_array, (_array.Length == 0) ? DefaultCapacity : 2 * _array.Length, _size);`
`248`		`- _array = newArray;`
	`246`	`+ Array.Resize(ref _array, (_array.Length == 0) ? DefaultCapacity : 2 * _array.Length);`
`249`	`247`	`}`
`250`	`248`	`_array[_size++] = item;`
`251`	`249`	`_version++;`