SelectProperty() [1/2]

override PropertyInfo System.DefaultBinder.SelectProperty ( BindingFlags bindingAttr, PropertyInfo[] match, Type returnType, Type[] indexes, ParameterModifier[] modifiers )

inlinesealedinherited

Definition at line 504 of file DefaultBinder.cs.

    {
        if (indexes != null)
        {
            foreach (Type type in indexes)
            {
                if (type == null)
                {
                    throw new ArgumentNullException("indexes");
                }
            }
        }
        if (match == null || match.Length == 0)
        {
            throw new ArgumentException(SR.Arg_EmptyArray, "match");
        }
        PropertyInfo[] array = (PropertyInfo[])match.Clone();
        int j = 0;
        int num = 0;
        int num2 = ((indexes != null) ? indexes.Length : 0);
        for (int k = 0; k < array.Length; k++)
        {
            if (indexes != null)
            {
                ParameterInfo[] indexParameters = array[k].GetIndexParameters();
                if (indexParameters.Length != num2)
                {
                    continue;
                }
                for (j = 0; j < num2; j++)
                {
                    Type parameterType = indexParameters[j].ParameterType;
                    if (parameterType == indexes[j] || parameterType == typeof(object))
                    {
                        continue;
                    }
                    if (parameterType.IsPrimitive)
                    {
                        if (!indexes[j].UnderlyingSystemType.IsRuntimeImplemented() || !CanChangePrimitive(indexes[j].UnderlyingSystemType, parameterType.UnderlyingSystemType))
                        {
                            break;
                        }
                    }
                    else if (!parameterType.IsAssignableFrom(indexes[j]))
                    {
                        break;
                    }
                }
            }
            if (j != num2)
            {
                continue;
            }
            if (returnType != null)
            {
                if (array[k].PropertyType.IsPrimitive)
                {
                    if (!returnType.UnderlyingSystemType.IsRuntimeImplemented() || !CanChangePrimitive(returnType.UnderlyingSystemType, array[k].PropertyType.UnderlyingSystemType))
                    {
                        continue;
                    }
                }
                else if (!array[k].PropertyType.IsAssignableFrom(returnType))
                {
                    continue;
                }
            }
            array[num++] = array[k];
        }
        switch (num)
        {
        case 0:
            return null;
        case 1:
            return array[0];
        default:
        {
            int num3 = 0;
            bool flag = false;
            int[] array2 = new int[num2];
            for (int k = 0; k < num2; k++)
            {
                array2[k] = k;
            }
            for (int k = 1; k < num; k++)
            {
                int num4 = FindMostSpecificType(array[num3].PropertyType, array[k].PropertyType, returnType);
                if (num4 == 0 && indexes != null)
                {
                    num4 = FindMostSpecific(array[num3].GetIndexParameters(), array2, null, array[k].GetIndexParameters(), array2, null, indexes, null);
                }
                if (num4 == 0)
                {
                    num4 = FindMostSpecificProperty(array[num3], array[k]);
                    if (num4 == 0)
                    {
                        flag = true;
                    }
                }
                if (num4 == 2)
                {
                    flag = false;
                    num3 = k;
                }
            }
            if (flag)
            {
                throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
            }
            return array[num3];
        }
        }
    }

References System.SR.Arg_AmbiguousMatchException, System.SR.Arg_EmptyArray, System.array, System.DefaultBinder.CanChangePrimitive(), System.DefaultBinder.FindMostSpecific(), System.DefaultBinder.FindMostSpecificProperty(), System.DefaultBinder.FindMostSpecificType(), System.Type.IsAssignableFrom(), System.Type.IsPrimitive, System.Type.IsRuntimeImplemented(), System.match, System.Reflection.ParameterInfo.ParameterType, System.type, and System.Type.UnderlyingSystemType.