Refactoring and small fixes.

Author: konard

Arrays/ArrayPool.cs

@@ -4,6 +4,9 @@ namespace Platform.Collections.Arrays
 {
     public static class ArrayPool
     {
+        public static readonly int DefaultSizesAmount = 512;
+        public static readonly int DefaultMaxArraysPerSize = 32;
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T[] Allocate<T>(long size) => ArrayPool<T>.GetOrCreateThreadInstance().Allocate(size);
 

Arrays/ArrayPool[T].cs

@@ -12,21 +12,19 @@ namespace Platform.Collections.Arrays
     /// </remarks>
     public class ArrayPool<T>
     {
-        public static readonly int DefaultSizesAmount = 512;
-        public static readonly int DefaultMaxArraysPerSize = 32;
         public static readonly T[] Empty = new T[0];
 
         // May be use Default class for that later.
         [ThreadStatic]
         internal static ArrayPool<T> ThreadInstance;
 
         private readonly int _maxArraysPerSize;
-        private readonly Dictionary<int, Stack<T[]>> _pool = new Dictionary<int, Stack<T[]>>(DefaultSizesAmount);
+        private readonly Dictionary<int, Stack<T[]>> _pool = new Dictionary<int, Stack<T[]>>(ArrayPool.DefaultSizesAmount);
 
         public ArrayPool(int maxArraysPerSize) => _maxArraysPerSize = maxArraysPerSize;
 
         public ArrayPool()
-           : this(DefaultMaxArraysPerSize)
+           : this(ArrayPool.DefaultMaxArraysPerSize)
         {
         }
 

Arrays/CharArrayExtensions.cs

@@ -9,9 +9,9 @@ public static int GenerateHashCode(this char[] array, int offset, int length)
         {
             var hashSeed = 5381;
             var hashAccumulator = hashSeed;
-            fixed (char* src = &array[offset])
+            fixed (char* pointer = &array[offset])
             {
-                for (char* s = src, last = s + length; s < last; s++)
+                for (char* s = pointer, last = s + length; s < last; s++)
                 {
                     hashAccumulator = (hashAccumulator << 5) + hashAccumulator ^ *s;
                 }
@@ -24,54 +24,54 @@ public static int GenerateHashCode(this char[] array, int offset, int length)
         /// </remarks>
         public static bool ContentEqualTo(this char[] left, int leftOffset, int length, char[] right, int rightOffset)
         {
-            fixed (char* ap = &left[leftOffset])
+            fixed (char* leftPointer = &left[leftOffset])
             {
-                fixed (char* bp = &right[rightOffset])
+                fixed (char* rightPointer = &right[rightOffset])
                 {
-                    char* a = ap, b = bp;
-                    if (!CheckArraysMainPartForEquality(ref a, ref b, ref length))
+                    char* leftPointerCopy = leftPointer, rightPointerCopy = rightPointer;
+                    if (!CheckArraysMainPartForEquality(ref leftPointerCopy, ref rightPointerCopy, ref length))
                     {
                         return false;
                     }
-                    CheckArraysRemainderForEquality(ref a, ref b, ref length);
+                    CheckArraysRemainderForEquality(ref leftPointerCopy, ref rightPointerCopy, ref length);
                     return length <= 0;
                 }
             }
         }
 
-        private static bool CheckArraysMainPartForEquality(ref char* a, ref char* b, ref int length)
+        private static bool CheckArraysMainPartForEquality(ref char* left, ref char* right, ref int length)
         {
             while (length >= 10)
             {
-                if ((*(int*)a != *(int*)b)
-                 || (*(int*)(a + 2) != *(int*)(b + 2))
-                 || (*(int*)(a + 4) != *(int*)(b + 4))
-                 || (*(int*)(a + 6) != *(int*)(b + 6))
-                 || (*(int*)(a + 8) != *(int*)(b + 8)))
+                if ((*(int*)left != *(int*)right)
+                 || (*(int*)(left + 2) != *(int*)(right + 2))
+                 || (*(int*)(left + 4) != *(int*)(right + 4))
+                 || (*(int*)(left + 6) != *(int*)(right + 6))
+                 || (*(int*)(left + 8) != *(int*)(right + 8)))
                 {
                     return false;
                 }
-                a += 10;
-                b += 10;
+                left += 10;
+                right += 10;
                 length -= 10;
             }
             return true;
         }
 
-        private static void CheckArraysRemainderForEquality(ref char* a, ref char* b, ref int length)
+        private static void CheckArraysRemainderForEquality(ref char* left, ref char* right, ref int length)
         {
             // This depends on the fact that the String objects are
             // always zero terminated and that the terminating zero is not included
             // in the length. For odd string sizes, the last compare will include
             // the zero terminator.
             while (length > 0)
             {
-                if (*(int*)a != *(int*)b)
+                if (*(int*)left != *(int*)right)
                 {
                     break;
                 }
-                a += 2;
-                b += 2;
+                left += 2;
+                right += 2;
                 length -= 2;
             }
         }