BinarySearch() [2/4]

static int System.Array.BinarySearch ( Array array, int index, int length, object? value, IComparer? comparer )

inlinestatic

Definition at line 1343 of file Array.cs.

    {
        if (array == null)
        {
            ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
        }
        int lowerBound = array.GetLowerBound(0);
        if (index < lowerBound)
        {
            ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
        }
        if (length < 0)
        {
            ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
        }
        if (array.Length - (index - lowerBound) < length)
        {
            ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
        }
        if (array.Rank != 1)
        {
            ThrowHelper.ThrowRankException(ExceptionResource.Rank_MultiDimNotSupported);
        }
        if (comparer == null)
        {
            comparer = Comparer.Default;
        }
        int num = index;
        int num2 = index + length - 1;
        if (array is object[] array2)
        {
            while (num <= num2)
            {
                int median = GetMedian(num, num2);
                int num3;
                try
                {
                    num3 = comparer.Compare(array2[median], value);
                }
                catch (Exception e)
                {
                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
                    return 0;
                }
                if (num3 == 0)
                {
                    return median;
                }
                if (num3 < 0)
                {
                    num = median + 1;
                }
                else
                {
                    num2 = median - 1;
                }
            }
            return ~num;
        }
        if (comparer == Comparer.Default)
        {
            CorElementType corElementTypeOfElementType = array.GetCorElementTypeOfElementType();
            if (corElementTypeOfElementType.IsPrimitiveType())
            {
                if (value == null)
                {
                    return ~index;
                }
                if (array.IsValueOfElementType(value))
                {
                    int adjustedIndex2 = index - lowerBound;
                    int num4 = -1;
                    switch (corElementTypeOfElementType)
                    {
                    case CorElementType.ELEMENT_TYPE_I1:
                        num4 = GenericBinarySearch<sbyte>(array, adjustedIndex2, length, value);
                        break;
                    case CorElementType.ELEMENT_TYPE_BOOLEAN:
                    case CorElementType.ELEMENT_TYPE_U1:
                        num4 = GenericBinarySearch<byte>(array, adjustedIndex2, length, value);
                        break;
                    case CorElementType.ELEMENT_TYPE_I2:
                        num4 = GenericBinarySearch<short>(array, adjustedIndex2, length, value);
                        break;
                    case CorElementType.ELEMENT_TYPE_CHAR:
                    case CorElementType.ELEMENT_TYPE_U2:
                        num4 = GenericBinarySearch<ushort>(array, adjustedIndex2, length, value);
                        break;
                    case CorElementType.ELEMENT_TYPE_I4:
                        num4 = GenericBinarySearch<int>(array, adjustedIndex2, length, value);
                        break;
                    case CorElementType.ELEMENT_TYPE_U4:
                        num4 = GenericBinarySearch<uint>(array, adjustedIndex2, length, value);
                        break;
                    case CorElementType.ELEMENT_TYPE_I8:
                    case CorElementType.ELEMENT_TYPE_I:
                        num4 = GenericBinarySearch<long>(array, adjustedIndex2, length, value);
                        break;
                    case CorElementType.ELEMENT_TYPE_U8:
                    case CorElementType.ELEMENT_TYPE_U:
                        num4 = GenericBinarySearch<ulong>(array, adjustedIndex2, length, value);
                        break;
                    case CorElementType.ELEMENT_TYPE_R4:
                        num4 = GenericBinarySearch<float>(array, adjustedIndex2, length, value);
                        break;
                    case CorElementType.ELEMENT_TYPE_R8:
                        num4 = GenericBinarySearch<double>(array, adjustedIndex2, length, value);
                        break;
                    }
                    if (num4 < 0)
                    {
                        return ~(index + ~num4);
                    }
                    return index + num4;
                }
            }
        }
        while (num <= num2)
        {
            int median2 = GetMedian(num, num2);
            int num5;
            try
            {
                num5 = comparer.Compare(array.GetValue(median2), value);
            }
            catch (Exception e2)
            {
                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e2);
                return 0;
            }
            if (num5 == 0)
            {
                return median2;
            }
            if (num5 < 0)
            {
                num = median2 + 1;
            }
            else
            {
                num2 = median2 - 1;
            }
        }
        return ~num;
        static int GenericBinarySearch<T>(Array array, int adjustedIndex, int length, object value) where T : struct, IComparable<T>
        {
            return UnsafeArrayAsSpan<T>(array, adjustedIndex, length).BinarySearch(Unsafe.As<byte, T>(ref value.GetRawData()));
        }
    }

References System.array, System.comparer, System.Collections.Generic.Comparer< T >.Default, System.Array.GetMedian(), System.index, System.length, System.T, System.ThrowHelper.ThrowArgumentException(), System.ThrowHelper.ThrowArgumentNullException(), System.ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException(), System.ThrowHelper.ThrowInvalidOperationException(), System.ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum(), System.ThrowHelper.ThrowRankException(), System.Array.UnsafeArrayAsSpan< T >(), and System.value.