Sort() [8/8]

static void System.Array.Sort ( Array keys, Array? items, int index, int length, IComparer? comparer )

inlinestatic

Definition at line 2380 of file Array.cs.

    {
        if (keys == null)
        {
            ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
        }
        if (keys.Rank != 1 || (items != null && items.Rank != 1))
        {
            ThrowHelper.ThrowRankException(ExceptionResource.Rank_MultiDimNotSupported);
        }
        int lowerBound = keys.GetLowerBound(0);
        if (items != null && lowerBound != items.GetLowerBound(0))
        {
            ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_LowerBoundsMustMatch);
        }
        if (index < lowerBound)
        {
            ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
        }
        if (length < 0)
        {
            ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
        }
        if (keys.Length - (index - lowerBound) < length || (items != null && index - lowerBound > items.Length - length))
        {
            ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
        }
        if (length <= 1)
        {
            return;
        }
        if (comparer == null)
        {
            comparer = Comparer.Default;
        }
        if (keys is object[] keys2)
        {
            object[] array = items as object[];
            if (items == null || array != null)
            {
                new SorterObjectArray(keys2, array, comparer).Sort(index, length);
                return;
            }
        }
        if (comparer == Comparer.Default)
        {
            CorElementType corElementTypeOfElementType = keys.GetCorElementTypeOfElementType();
            if (items == null || items.GetCorElementTypeOfElementType() == corElementTypeOfElementType)
            {
                int adjustedIndex2 = index - lowerBound;
                switch (corElementTypeOfElementType)
                {
                case CorElementType.ELEMENT_TYPE_I1:
                    GenericSort<sbyte>(keys, items, adjustedIndex2, length);
                    return;
                case CorElementType.ELEMENT_TYPE_BOOLEAN:
                case CorElementType.ELEMENT_TYPE_U1:
                    GenericSort<byte>(keys, items, adjustedIndex2, length);
                    return;
                case CorElementType.ELEMENT_TYPE_I2:
                    GenericSort<short>(keys, items, adjustedIndex2, length);
                    return;
                case CorElementType.ELEMENT_TYPE_CHAR:
                case CorElementType.ELEMENT_TYPE_U2:
                    GenericSort<ushort>(keys, items, adjustedIndex2, length);
                    return;
                case CorElementType.ELEMENT_TYPE_I4:
                    GenericSort<int>(keys, items, adjustedIndex2, length);
                    return;
                case CorElementType.ELEMENT_TYPE_U4:
                    GenericSort<uint>(keys, items, adjustedIndex2, length);
                    return;
                case CorElementType.ELEMENT_TYPE_I8:
                case CorElementType.ELEMENT_TYPE_I:
                    GenericSort<long>(keys, items, adjustedIndex2, length);
                    return;
                case CorElementType.ELEMENT_TYPE_U8:
                case CorElementType.ELEMENT_TYPE_U:
                    GenericSort<ulong>(keys, items, adjustedIndex2, length);
                    return;
                case CorElementType.ELEMENT_TYPE_R4:
                    GenericSort<float>(keys, items, adjustedIndex2, length);
                    return;
                case CorElementType.ELEMENT_TYPE_R8:
                    GenericSort<double>(keys, items, adjustedIndex2, length);
                    return;
                }
            }
        }
        new SorterGenericArray(keys, items, comparer).Sort(index, length);
        static void GenericSort<T>(Array keys, Array items, int adjustedIndex, int length) where T : struct
        {
            Span<T> span = UnsafeArrayAsSpan<T>(keys, adjustedIndex, length);
            if (items != null)
            {
                span.Sort(UnsafeArrayAsSpan<T>(items, adjustedIndex, length));
            }
            else
            {
                span.Sort();
            }
        }
    }

References System.array, System.comparer, System.Collections.Generic.Comparer< T >.Default, System.Array.GetCorElementTypeOfElementType(), System.Array.GetLowerBound(), System.index, System.keys, System.length, System.Array.Length, System.Array.Rank, System.Array.SorterObjectArray.Sort(), System.Array.SorterGenericArray.Sort(), System.T, System.ThrowHelper.ThrowArgumentException(), System.ThrowHelper.ThrowArgumentNullException(), System.ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException(), System.ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum(), System.ThrowHelper.ThrowRankException(), and System.Array.UnsafeArrayAsSpan< T >().