Use Buffer.BlockCopy with byte[]

In particular after dotnet/coreclr#3118, Buffer.BlockCopy has less overhead than Array.Copy when copying byte[]s, such that there's no benefit to using Array.Copy and potential benefit to using Buffer.BlockCopy.

This commit replaces usage of Array.Copy(byte[], ...) in corefx with Buffer.BlockCopy(byte[], ...).  A lot of places were already using it.

(In a few places where we weren't passing lower bounds to Array.Copy with T[] arguments, I added explicit lower bounds as well to avoid the overload needing to call GetLowerBound.)

Author: stephentoub

src/Common/src/System/Net/Logging/GlobalLog.cs

@@ -248,7 +248,7 @@ public static void Dump(byte[] buffer, int offset, int length)
             }
 
             var bufferSegment = new byte[length];
-            Array.Copy(buffer, offset, bufferSegment, 0, length);
+            Buffer.BlockCopy(buffer, offset, bufferSegment, 0, length);
             EventSourceLogging.Log.DebugDumpArray(bufferSegment);
         }
 

src/Common/src/System/Security/Cryptography/RSAOpenSsl.cs

@@ -108,7 +108,7 @@ public override byte[] Decrypt(byte[] data, RSAEncryptionPadding padding)
             }
 
             byte[] plainBytes = new byte[returnValue];
-            Array.Copy(buf, 0, plainBytes, 0, returnValue);
+            Buffer.BlockCopy(buf, 0, plainBytes, 0, returnValue);
             return plainBytes;
         }
 

src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Symbols/SymbolManagerBase.cs

@@ -400,7 +400,7 @@ public TypeArray AllocParams(params CType[] types)
         public TypeArray ConcatParams(CType[] prgtype1, CType[] prgtype2)
         {
             CType[] combined = new CType[prgtype1.Length + prgtype2.Length];
-            Array.Copy(prgtype1, combined, prgtype1.Length);
+            Array.Copy(prgtype1, 0, combined, 0, prgtype1.Length);
             Array.Copy(prgtype2, 0, combined, prgtype1.Length, prgtype2.Length);
             return AllocParams(combined);
         }

src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/UIHintAttribute.cs

@@ -100,7 +100,7 @@ public UIHintImplementation(string uiHint, string presentationLayer, params obje
                 if (controlParameters != null)
                 {
                     _inputControlParameters = new object[controlParameters.Length];
-                    Array.Copy(controlParameters, _inputControlParameters, controlParameters.Length);
+                    Array.Copy(controlParameters, 0, _inputControlParameters, 0, controlParameters.Length);
                 }
             }
 

src/System.Data.SqlClient/src/System/Data/Common/DataRecordInternal.cs

@@ -143,7 +143,7 @@ public override long GetBytes(int i, long dataIndex, byte[] buffer, int bufferIn
                 }
 
                 // until arrays are 64 bit, we have to do these casts
-                Array.Copy(data, ndataIndex, buffer, bufferIndex, (int)cbytes);
+                Buffer.BlockCopy(data, ndataIndex, buffer, bufferIndex, (int)cbytes);
             }
             catch (Exception e)
             {

src/System.Data.SqlClient/src/System/Data/Sql/SqlMetaData.cs

@@ -942,7 +942,7 @@ public SqlBinary Adjust(SqlBinary value)
                     {
                         byte[] rgbValue = value.Value;
                         byte[] rgbNewValue = new byte[MaxLength];
-                        Array.Copy(rgbValue, 0, rgbNewValue, 0, rgbValue.Length);
+                        Buffer.BlockCopy(rgbValue, 0, rgbNewValue, 0, rgbValue.Length);
                         Array.Clear(rgbNewValue, rgbValue.Length, rgbNewValue.Length - rgbValue.Length);
                         return new SqlBinary(rgbNewValue);
                     }
@@ -963,7 +963,7 @@ public SqlBinary Adjust(SqlBinary value)
             {
                 byte[] rgbValue = value.Value;
                 byte[] rgbNewValue = new byte[MaxLength];
-                Array.Copy(rgbValue, 0, rgbNewValue, 0, (int)MaxLength);
+                Buffer.BlockCopy(rgbValue, 0, rgbNewValue, 0, (int)MaxLength);
                 value = new SqlBinary(rgbNewValue);
             }
 
@@ -1040,7 +1040,7 @@ public SqlBytes Adjust(SqlBytes value)
                         if (value.MaxLength < MaxLength)
                         {
                             byte[] rgbNew = new byte[MaxLength];
-                            Array.Copy(value.Buffer, 0, rgbNew, 0, (int)oldLength);
+                            Buffer.BlockCopy(value.Buffer, 0, rgbNew, 0, (int)oldLength);
                             value = new SqlBytes(rgbNew);
                         }
 
@@ -1380,7 +1380,7 @@ public byte[] Adjust(byte[] value)
                     if (value.Length < MaxLength)
                     {
                         byte[] rgbNewValue = new byte[MaxLength];
-                        Array.Copy(value, 0, rgbNewValue, 0, value.Length);
+                        Buffer.BlockCopy(value, 0, rgbNewValue, 0, value.Length);
                         Array.Clear(rgbNewValue, value.Length, (int)rgbNewValue.Length - value.Length);
                         return rgbNewValue;
                     }
@@ -1400,7 +1400,7 @@ public byte[] Adjust(byte[] value)
             if (value.Length > MaxLength && Max != MaxLength)
             {
                 byte[] rgbNewValue = new byte[MaxLength];
-                Array.Copy(value, 0, rgbNewValue, 0, (int)MaxLength);
+                Buffer.BlockCopy(value, 0, rgbNewValue, 0, (int)MaxLength);
                 value = rgbNewValue;
             }
 

src/System.Data.SqlClient/src/System/Data/SqlClient/SNI/SNIPacket.cs

@@ -124,7 +124,7 @@ public SNIPacket Clone()
         {
             SNIPacket packet = new SNIPacket(null);
             packet._data = new byte[_length];
-            Array.Copy(_data, 0, packet._data, 0, _length);
+            Buffer.BlockCopy(_data, 0, packet._data, 0, _length);
             packet._length = _length;
 
             return packet;

src/System.Data.SqlClient/src/System/Data/SqlClient/SqlDataReader.cs

@@ -1374,7 +1374,7 @@ private bool TryGetBytesInternal(int i, long dataIndex, byte[] buffer, int buffe
                         cbytes = length;
                 }
 
-                Array.Copy(data, ndataIndex, buffer, bufferIndex, cbytes);
+                Buffer.BlockCopy(data, ndataIndex, buffer, bufferIndex, cbytes);
             }
             catch (Exception e)
             {

src/System.Data.SqlClient/src/System/Data/SqlClient/SqlSequentialTextReader.cs

@@ -371,7 +371,7 @@ private byte[] PrepareByteBuffer(int numberOfChars, out int byteBufferUsed)
                     {
                         // Otherwise, copy over the leftover buffer
                         byteBuffer = new byte[byteBufferSize];
-                        Array.Copy(_leftOverBytes, byteBuffer, _leftOverBytes.Length);
+                        Buffer.BlockCopy(_leftOverBytes, 0, byteBuffer, 0, _leftOverBytes.Length);
                         byteBufferUsed = _leftOverBytes.Length;
                     }
                 }
@@ -410,7 +410,7 @@ private int DecodeBytesToChars(byte[] inBuffer, int inBufferCount, char[] outBuf
             if ((!completed) && (bytesUsed < inBufferCount))
             {
                 _leftOverBytes = new byte[inBufferCount - bytesUsed];
-                Array.Copy(inBuffer, bytesUsed, _leftOverBytes, 0, _leftOverBytes.Length);
+                Buffer.BlockCopy(inBuffer, bytesUsed, _leftOverBytes, 0, _leftOverBytes.Length);
             }
             else
             {

src/System.Data.SqlClient/src/System/Data/SqlClient/SqlStream.cs

@@ -452,7 +452,7 @@ override public int Read(byte[] buffer, int offset, int count)
                 cb = _cachedBytes[_currentArrayIndex].Length - _currentPosition;
                 if (cb > count)
                     cb = count;
-                Array.Copy(_cachedBytes[_currentArrayIndex], _currentPosition, buffer, offset, cb);
+                Buffer.BlockCopy(_cachedBytes[_currentArrayIndex], _currentPosition, buffer, offset, cb);
 
                 _currentPosition += cb;
                 count -= (int)cb;