class MergeSort
{
    public void ParallelSort(int[] values)
    {
        int[] aux = new int[values.Length];
        Start = DateTime.Now.Ticks;

        int lo = 0;
        int hi = values.Length - 1;
        int mid = values.Length / 2;

        Sort(values, aux, lo, mid, hi);

        End = DateTime.Now.Ticks;
    }

    private void Sort(int[] values, int[] aux, int lo, int mid, int hi)
    {
        if (hi - lo > 32)
        {
            Parallel.Invoke(
                () => Sort(values, aux, lo, (mid + lo)/2, mid),
                () => Sort(values, aux, mid + 1, (hi + mid)/2, hi));
            Merge(values, aux, lo, mid, hi);

        }
        else
            InsertionSort.Sort(values, lo, hi);
    }
    private unsafe void Merge(int[] values, int[] aux, int lo, int mid, int hi)
    {
        Buffer.BlockCopy(values, sizeof(int)* lo, aux, sizeof(int) * lo, sizeof(int) * (hi-lo + 1));

        int i = lo;
        int j = mid+1;

        fixed (int* a = values, b = aux)
        {
            for (int k = lo; k <= hi; k++)
            {
                if (i > mid)
                    a[k] = b[j++];
                else if (j > hi)
                    a[k] = b[i++];
                else if (b[i] < b[j])
                    a[k] = b[i++];
                else
                    a[k] = b[j++];
            }
        }

    }
}

class InsertionSort
{
    public static unsafe void Sort(int[] values, int lo, int hi)
    {
        fixed (int* b = &values[0])
        {
            for (int i = lo+1; i <= hi; i++)
            {
                int tmp = b[i];
                int j;
                for (j = i; j > 0 && tmp < b[j - 1]; j--)
                    b[j] = b[j - 1];
                b[j] = tmp;
            }
        }
    }
}

Thread 3 slice: 93-123 IsSorted: False
Thread 6 slice: 62-92 IsSorted: False
Thread 10 slice: 0-30 IsSorted: True
Thread 9 slice: 124-154 IsSorted: False
Thread 7 slice: 185-214 IsSorted: True
Thread 5 slice: 31-61 IsSorted: False
Thread 8 slice: 155-184 IsSorted: False
Thread 4 slice: 215-245 IsSorted: False

for (j = i; j > lo && tmp < b[j - 1]; j--)

for (j = i; j > 0 && tmp < b[j - 1]; j--)