private static void AddLiftedOperators(Type type, string methodName, OperatorGrouping group, Type arg1, Type arg2, List<MethodInfo> candidates)
 {
     int num = 0;
     foreach (MethodInfo info in type.GetMethods(BindingFlags.Public | BindingFlags.Static))
     {
         ParameterInfo[] parameters = info.GetParameters();
         if ((info.Name == methodName) && (parameters.Length == 2))
         {
             MethodInfo item = EvaluateLiftedMethod(info, parameters, group, arg1, arg2);
             if (item != null)
             {
                 num++;
                 if (!candidates.Contains(item))
                 {
                     candidates.Add(item);
                 }
             }
         }
     }
     if ((num <= 0) && (type != typeof(object)))
     {
         type = type.BaseType;
         if (type != null)
         {
             foreach (MethodInfo info3 in type.GetMethods(BindingFlags.Public | BindingFlags.Static))
             {
                 ParameterInfo[] infoArray3 = info3.GetParameters();
                 if ((info3.Name == methodName) && (infoArray3.Length == 2))
                 {
                     MethodInfo info4 = EvaluateLiftedMethod(info3, infoArray3, group, arg1, arg2);
                     if ((info4 != null) && !candidates.Contains(info4))
                     {
                         candidates.Add(info4);
                     }
                 }
             }
         }
     }
 }
Ejemplo n.º 2
0
 private static MethodInfo EvaluateLiftedMethod(MethodInfo mi, ParameterInfo[] parameters, OperatorGrouping group, Type arg1, Type arg2)
 {
     Type parm1 = parameters[0].ParameterType;
     Type parm2 = parameters[1].ParameterType;
     if (ConditionHelper.IsNonNullableValueType(parm1) && ConditionHelper.IsNonNullableValueType(parm2))
     {
         // lift the parameters for testing conversions, if possible
         parm1 = typeof(Nullable<>).MakeGenericType(parm1);
         parm2 = typeof(Nullable<>).MakeGenericType(parm2);
         switch (group)
         {
             case OperatorGrouping.Equality:     // for == !=
                 if (mi.ReturnType == typeof(bool) &&
                     RuleValidation.ImplicitConversion(arg1, parm1) &&
                     RuleValidation.ImplicitConversion(arg2, parm2))
                 {
                     return new LiftedEqualityOperatorMethodInfo(mi);
                 }
                 break;
             case OperatorGrouping.Relational:       // for < > <= >=
                 if (mi.ReturnType == typeof(bool) &&
                     RuleValidation.ImplicitConversion(arg1, parm1) &&
                     RuleValidation.ImplicitConversion(arg2, parm2))
                 {
                     return new LiftedRelationalOperatorMethodInfo(mi);
                 }
                 break;
             case OperatorGrouping.Arithmetic:       // for + - * / % & ^
                 if (ConditionHelper.IsNonNullableValueType(mi.ReturnType) &&
                     RuleValidation.ImplicitConversion(arg1, parm1) &&
                     RuleValidation.ImplicitConversion(arg2, parm2))
                 {
                     return new LiftedArithmeticOperatorMethodInfo(mi);
                 }
                 break;
         }
     }
     return null;
 }
Ejemplo n.º 3
0
        private static void AddLiftedOperators(Type type, string methodName, OperatorGrouping group, Type arg1, Type arg2, List<MethodInfo> candidates)
        {
            // append the list of lifted methods that match the name specified
            int numAdded = 0;
            MethodInfo[] possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
            foreach (MethodInfo mi in possible)
            {
                ParameterInfo[] parameters = mi.GetParameters();
                if ((mi.Name == methodName) && (parameters.Length == 2))
                {
                    MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2);
                    if (liftedMethod != null)
                    {
                        ++numAdded;
                        if (!candidates.Contains(liftedMethod))
                            candidates.Add(liftedMethod);
                    }
                }
            }
            if ((numAdded > 0) || (type == typeof(object)))
                return;

            // no matches, check direct base class (if there is one)
            type = type.BaseType;
            if (type != null)
            {
                possible = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
                foreach (MethodInfo mi in possible)
                {
                    ParameterInfo[] parameters = mi.GetParameters();
                    if ((mi.Name == methodName) && (parameters.Length == 2))
                    {
                        MethodInfo liftedMethod = EvaluateLiftedMethod(mi, parameters, group, arg1, arg2);
                        if ((liftedMethod != null) && !candidates.Contains(liftedMethod))
                            candidates.Add(liftedMethod);
                    }
                }
            }
        }
        private static MethodInfo EvaluateLiftedMethod(MethodInfo mi, ParameterInfo[] parameters, OperatorGrouping group, Type arg1, Type arg2)
        {
            Type parameterType = parameters[0].ParameterType;
            Type type = parameters[1].ParameterType;
            if (ConditionHelper.IsNonNullableValueType(parameterType) && ConditionHelper.IsNonNullableValueType(type))
            {
                parameterType = typeof(Nullable<>).MakeGenericType(new Type[] { parameterType });
                type = typeof(Nullable<>).MakeGenericType(new Type[] { type });
                switch (group)
                {
                    case OperatorGrouping.Arithmetic:
                        if ((!ConditionHelper.IsNonNullableValueType(mi.ReturnType) || !RuleValidation.ImplicitConversion(arg1, parameterType)) || !RuleValidation.ImplicitConversion(arg2, type))
                        {
                            break;
                        }
                        return new LiftedArithmeticOperatorMethodInfo(mi);

                    case OperatorGrouping.Equality:
                        if ((!(mi.ReturnType == typeof(bool)) || !RuleValidation.ImplicitConversion(arg1, parameterType)) || !RuleValidation.ImplicitConversion(arg2, type))
                        {
                            break;
                        }
                        return new LiftedEqualityOperatorMethodInfo(mi);

                    case OperatorGrouping.Relational:
                        if ((!(mi.ReturnType == typeof(bool)) || !RuleValidation.ImplicitConversion(arg1, parameterType)) || !RuleValidation.ImplicitConversion(arg2, type))
                        {
                            break;
                        }
                        return new LiftedRelationalOperatorMethodInfo(mi);
                }
            }
            return null;
        }