Clean MergeSort attempt 3

///////////////////////////////////////////////////////////////////////////////////////// CLASS
public class MergeSort
{
    private int[] toSort;

    public MergeSort(int[] toSort)
    {
        this.toSort = toSort;
    }

    public int[] Sort()
    {
        int[] sorted = new int[toSort.Length];
        int[] tmp = new int[toSort.Length];

        new MergeSortInternal(new SubArray(toSort), new SubArray(sorted), new SubArray(tmp)).Sort();

        return sorted;
    }
}

///////////////////////////////////////////////////////////////////////////////////////// CLASS
class SubArray
{
    private int leftIndex, rightIndex;
    public readonly int[] array;

    public int Length { get { return rightIndex - leftIndex + 1; } }
    public bool IsEmpty { get { return leftIndex > rightIndex} }
    public int FrontElement { get { return array[leftIndex]; } }

    public int this[int i]
    {
        get { return array[leftIndex + i]; }
        set { array[leftIndex + i] = value; }
    }

    public SubArray(int[] array)
        : this(array, 0, array.Length)
    { }

    public SubArray(int[] array, int leftIndex, int rightIndex)
    {
        this.array = array;
        this.leftIndex = leftIndex;
        this.rightIndex = rightIndex;
    }

    public Tuple<SubArray, SubArray> SplitInTheMiddle()
    {
        int middle = (leftIndex + rightIndex) / 2;
        int leftSideEnd = middle;
        int rightSideStart = middle + 1;

        SubArray leftSide = new SubArray(array, leftIndex, leftSideEnd);
        SubArray rightSide = new SubArray(array, rightSideStart, rightIndex);

        return new Tuple<SubArray,SubArray>(leftSide, rightSide);
    }

    public int TakeFrontElement()
    {
        int result = array[leftIndex];
        leftIndex++;
        return result;
    }
}

///////////////////////////////////////////////////////////////////////////////////////// CLASS
class MergeSortInternal
{
    private SubArray toSort;
    private SubArray sorted;
    private SubArray tmp;


    public MergeSortInternal(SubArray toSort, SubArray sorted, SubArray tmp)
    {
        this.toSort = toSort;
        this.sorted = sorted;
        this.tmp = tmp;
    }

    public void Sort()
    {
        if(toSort.Length == 1)
            SortOneElementList();
        else
        {
            var sortedSubArrays = RecursivelySortBothHalfsOfTheArray();
            MergeSubArrays(sortedSubArrays.Item1, sortedSubArrays.Item2);
        }
    }

    private void SortOneElementList()
    {
        sorted[0] = toSort[0];
    }

    private Tuple<SubArray, SubArray> RecursivelySortBothHalfsOfTheArray()
    {
        // Split arrays
        Tuple<SubArray,SubArray> splitToSort = toSort.SplitInTheMiddle();
        Tuple<SubArray,SubArray> splitTmp = tmp.SplitInTheMiddle();
        Tuple<SubArray,SubArray> splitSorted = sorted.SplitInTheMiddle();

        // Sort both parts of toSort into tmp
        new MergeSortInternal(splitToSort.Item1, splitTmp.Item1, splitSorted.Item1).Sort();
        new MergeSortInternal(splitToSort.Item2, splitTmp.Item2, splitSorted.Item2).Sort();

        return new Tuple<SubArray, SubArray>(slitTmp.Item1, splitTmp.Item2);
    }

    private void MergeSubArrays(SubArray left, SubArray right)
    {
        for (int i = 0; i < sorted.Length i++)
        {
            if(left.IsEmpty())
                sorted[i] = right.TakeFrontElement();
            else if(right.IsEmpty())
                sorted[i] = left.TakeFrontElement();
            else if(left.FrontElement < right.FrontElement)
                sorted[i] = left.TakeFrontElement();
            else
                sorted[i] = right.TakeFrontElement();
        }

        return sorted;
    }
}