BindToMethod() [2/2]

override MethodBase System.DefaultBinder.BindToMethod ( BindingFlags bindingAttr, MethodBase[] match, ref object[] args, ParameterModifier[] modifiers, CultureInfo cultureInfo, string[] names, out object state )

inlinesealedinherited

Definition at line 67 of file DefaultBinder.cs.

    {
        if (match == null || match.Length == 0)
        {
            throw new ArgumentException(SR.Arg_EmptyArray, "match");
        }
        MethodBase[] array = (MethodBase[])match.Clone();
        state = null;
        int[][] array2 = new int[array.Length][];
        for (int i = 0; i < array.Length; i++)
        {
            ParameterInfo[] parametersNoCopy = array[i].GetParametersNoCopy();
            array2[i] = new int[(parametersNoCopy.Length > args.Length) ? parametersNoCopy.Length : args.Length];
            if (names == null)
            {
                for (int j = 0; j < args.Length; j++)
                {
                    array2[i][j] = j;
                }
            }
            else if (!CreateParamOrder(array2[i], parametersNoCopy, names))
            {
                array[i] = null;
            }
        }
        Type[] array3 = new Type[array.Length];
        Type[] array4 = new Type[args.Length];
        for (int i = 0; i < args.Length; i++)
        {
            if (args[i] != null)
            {
                array4[i] = args[i].GetType();
            }
        }
        int num = 0;
        bool flag = (bindingAttr & BindingFlags.OptionalParamBinding) != 0;
        for (int i = 0; i < array.Length; i++)
        {
            Type type = null;
            if (array[i] == null)
            {
                continue;
            }
            ParameterInfo[] parametersNoCopy2 = array[i].GetParametersNoCopy();
            if (parametersNoCopy2.Length == 0)
            {
                if (args.Length == 0 || (array[i].CallingConvention & CallingConventions.VarArgs) != 0)
                {
                    array2[num] = array2[i];
                    array[num++] = array[i];
                }
                continue;
            }
            int j;
            if (parametersNoCopy2.Length > args.Length)
            {
                for (j = args.Length; j < parametersNoCopy2.Length - 1 && parametersNoCopy2[j].DefaultValue != DBNull.Value; j++)
                {
                }
                if (j != parametersNoCopy2.Length - 1)
                {
                    continue;
                }
                if (parametersNoCopy2[j].DefaultValue == DBNull.Value)
                {
                    if (!parametersNoCopy2[j].ParameterType.IsArray || !parametersNoCopy2[j].IsDefined(typeof(ParamArrayAttribute), inherit: true))
                    {
                        continue;
                    }
                    type = parametersNoCopy2[j].ParameterType.GetElementType();
                }
            }
            else if (parametersNoCopy2.Length < args.Length)
            {
                int num2 = parametersNoCopy2.Length - 1;
                if (!parametersNoCopy2[num2].ParameterType.IsArray || !parametersNoCopy2[num2].IsDefined(typeof(ParamArrayAttribute), inherit: true) || array2[i][num2] != num2)
                {
                    continue;
                }
                type = parametersNoCopy2[num2].ParameterType.GetElementType();
            }
            else
            {
                int num3 = parametersNoCopy2.Length - 1;
                if (parametersNoCopy2[num3].ParameterType.IsArray && parametersNoCopy2[num3].IsDefined(typeof(ParamArrayAttribute), inherit: true) && array2[i][num3] == num3 && !parametersNoCopy2[num3].ParameterType.IsAssignableFrom(array4[num3]))
                {
                    type = parametersNoCopy2[num3].ParameterType.GetElementType();
                }
            }
            int num4 = ((type != null) ? (parametersNoCopy2.Length - 1) : args.Length);
            for (j = 0; j < num4; j++)
            {
                Type type2 = parametersNoCopy2[j].ParameterType;
                if (type2.IsByRef)
                {
                    type2 = type2.GetElementType();
                }
                if (type2 == array4[array2[i][j]] || (flag && args[array2[i][j]] == Type.Missing) || args[array2[i][j]] == null || type2 == typeof(object))
                {
                    continue;
                }
                if (type2.IsPrimitive)
                {
                    if (array4[array2[i][j]] == null || !CanChangePrimitive(args[array2[i][j]]?.GetType(), type2))
                    {
                        break;
                    }
                }
                else if (!(array4[array2[i][j]] == null) && !type2.IsAssignableFrom(array4[array2[i][j]]) && (!array4[array2[i][j]].IsCOMObject || !type2.IsInstanceOfType(args[array2[i][j]])))
                {
                    break;
                }
            }
            if (type != null && j == parametersNoCopy2.Length - 1)
            {
                for (; j < args.Length; j++)
                {
                    if (type.IsPrimitive)
                    {
                        if (array4[j] == null || !CanChangePrimitive(args[j]?.GetType(), type))
                        {
                            break;
                        }
                    }
                    else if (!(array4[j] == null) && !type.IsAssignableFrom(array4[j]) && (!array4[j].IsCOMObject || !type.IsInstanceOfType(args[j])))
                    {
                        break;
                    }
                }
            }
            if (j == args.Length)
            {
                array2[num] = array2[i];
                array3[num] = type;
                array[num++] = array[i];
            }
        }
        switch (num)
        {
        case 0:
            throw new MissingMethodException(SR.MissingMember);
        case 1:
        {
            if (names != null)
            {
                state = new BinderState((int[])array2[0].Clone(), args.Length, array3[0] != null);
                ReorderParams(array2[0], args);
            }
            ParameterInfo[] parametersNoCopy4 = array[0].GetParametersNoCopy();
            if (parametersNoCopy4.Length == args.Length)
            {
                if (array3[0] != null)
                {
                    object[] array8 = new object[parametersNoCopy4.Length];
                    int num8 = parametersNoCopy4.Length - 1;
                    Array.Copy(args, array8, num8);
                    array8[num8] = Array.CreateInstance(array3[0], 1);
                    ((Array)array8[num8]).SetValue(args[num8], 0);
                    args = array8;
                }
            }
            else if (parametersNoCopy4.Length > args.Length)
            {
                object[] array9 = new object[parametersNoCopy4.Length];
                int i;
                for (i = 0; i < args.Length; i++)
                {
                    array9[i] = args[i];
                }
                for (; i < parametersNoCopy4.Length - 1; i++)
                {
                    array9[i] = parametersNoCopy4[i].DefaultValue;
                }
                if (array3[0] != null)
                {
                    array9[i] = Array.CreateInstance(array3[0], 0);
                }
                else
                {
                    array9[i] = parametersNoCopy4[i].DefaultValue;
                }
                args = array9;
            }
            else if ((array[0].CallingConvention & CallingConventions.VarArgs) == 0)
            {
                object[] array10 = new object[parametersNoCopy4.Length];
                int num9 = parametersNoCopy4.Length - 1;
                Array.Copy(args, array10, num9);
                array10[num9] = Array.CreateInstance(array3[0], args.Length - num9);
                Array.Copy(args, num9, (Array)array10[num9], 0, args.Length - num9);
                args = array10;
            }
            return array[0];
        }
        default:
        {
            int num5 = 0;
            bool flag2 = false;
            for (int i = 1; i < num; i++)
            {
                switch (FindMostSpecificMethod(array[num5], array2[num5], array3[num5], array[i], array2[i], array3[i], array4, args))
                {
                case 0:
                    flag2 = true;
                    break;
                case 2:
                    num5 = i;
                    flag2 = false;
                    break;
                }
            }
            if (flag2)
            {
                throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
            }
            if (names != null)
            {
                state = new BinderState((int[])array2[num5].Clone(), args.Length, array3[num5] != null);
                ReorderParams(array2[num5], args);
            }
            ParameterInfo[] parametersNoCopy3 = array[num5].GetParametersNoCopy();
            if (parametersNoCopy3.Length == args.Length)
            {
                if (array3[num5] != null)
                {
                    object[] array5 = new object[parametersNoCopy3.Length];
                    int num6 = parametersNoCopy3.Length - 1;
                    Array.Copy(args, array5, num6);
                    array5[num6] = Array.CreateInstance(array3[num5], 1);
                    ((Array)array5[num6]).SetValue(args[num6], 0);
                    args = array5;
                }
            }
            else if (parametersNoCopy3.Length > args.Length)
            {
                object[] array6 = new object[parametersNoCopy3.Length];
                int i;
                for (i = 0; i < args.Length; i++)
                {
                    array6[i] = args[i];
                }
                for (; i < parametersNoCopy3.Length - 1; i++)
                {
                    array6[i] = parametersNoCopy3[i].DefaultValue;
                }
                if (array3[num5] != null)
                {
                    array6[i] = Array.CreateInstance(array3[num5], 0);
                }
                else
                {
                    array6[i] = parametersNoCopy3[i].DefaultValue;
                }
                args = array6;
            }
            else if ((array[num5].CallingConvention & CallingConventions.VarArgs) == 0)
            {
                object[] array7 = new object[parametersNoCopy3.Length];
                int num7 = parametersNoCopy3.Length - 1;
                Array.Copy(args, array7, num7);
                array7[num7] = Array.CreateInstance(array3[num5], args.Length - num7);
                Array.Copy(args, num7, (Array)array7[num7], 0, args.Length - num7);
                args = array7;
            }
            return array[num5];
        }
        }
    }

References System.SR.Arg_AmbiguousMatchException, System.SR.Arg_EmptyArray, System.array, System.Reflection.Array, System.DefaultBinder.CanChangePrimitive(), System.Array.Copy(), System.Array.CreateInstance(), System.DefaultBinder.CreateParamOrder(), System.Reflection.ParameterInfo.DefaultValue, System.DefaultBinder.FindMostSpecificMethod(), System.Type.GetElementType(), System.Type.GetType(), System.Type.IsAssignableFrom(), System.Type.IsByRef, System.Type.IsCOMObject, System.Reflection.ParameterInfo.IsDefined(), System.Type.IsInstanceOfType(), System.Type.IsPrimitive, System.match, System.Type.Missing, System.SR.MissingMember, System.Reflection.ParameterInfo.ParameterType, System.DefaultBinder.ReorderParams(), System.state, System.type, and System.DBNull.Value.