Beispiel #1
0
        GetMethodCallExpression
        (
            this MethodInfo methodInfo,
            object obj = null,
            params IParamValGetterExpressionInfo[] paramValGetterExpressionInfos
        )
        {
            if (methodInfo == null)
            {
                return(null, null);
            }

            Expression GetParamExpression(string paramName, Type paramType)
            {
                IParamValGetterExpressionInfo paramValGetterExpressionInfo =
                    paramValGetterExpressionInfos
                    .FirstOrDefault
                    (
                        paramValExpressionInfo =>
                        paramValExpressionInfo.ParamName == paramName);

                if (paramValGetterExpressionInfo == null)
                {
                    return(Expression.Parameter(paramType, paramName));
                }
                else
                {
                    Expression resultExpression =
                        Expression.Convert(paramValGetterExpressionInfo.ValueGetterExpression, paramType);

                    return(resultExpression);
                }
            }

            // obtains the expressions for the MethodInfo parameters including the expressions
            // to be passed from the Wrapper Method - they are of type ParameterExpression and
            // the expressions to obtain the value via IParamValGetterExpressionInfo.ValueGetterExpression
            // and conversion (of type UnaryExpression)
            Expression[] paramExpressions =
                methodInfo.GetParameters()
                .Select(paramInfo => GetParamExpression(paramInfo.Name, paramInfo.ParameterType))
                .ToArray();

            Expression instanceExpr =
                obj != null?Expression.Constant(obj) : null;

            MethodCallExpression methodCallExpression =
                Expression.Call(instanceExpr, methodInfo, paramExpressions);

            return(methodCallExpression, paramExpressions.OfType <ParameterExpression>().ToArray());
        }
Beispiel #2
0
        GetMethodCallForOriginalMethodFromTakingObjArgs
        (
            this MethodInfo methodInfoForMethodAcceptingObjArray,
            IEnumerable <ParamInfo> paramInfos,
            object obj = null,
            params IParamValGetterExpressionInfo[] paramValGetterExpressionInfos)
        {
            Expression GetParamExpression(string paramName, Type paramType)
            {
                IParamValGetterExpressionInfo paramValGetterExpressionInfo =
                    paramValGetterExpressionInfos
                    .FirstOrDefault
                    (
                        paramValExpressionInfo =>
                        paramValExpressionInfo.ParamName == paramName);

                if (paramValGetterExpressionInfo == null)
                {
                    return(Expression.Parameter(paramType, paramName));
                }
                else
                {
                    return(paramValGetterExpressionInfo.ValueGetterExpression);
                }
            }

            Expression[] parameterExpressions =
                paramInfos
                ?.Select(paramInfo => GetParamExpression(paramInfo.ParamName, paramInfo.ParamType))
                ?.ToArray();

            Expression[] objExpressions =
                parameterExpressions
                ?.Select(paramExpr => Expression.Convert(paramExpr, typeof(object)))
                ?.ToArray();

            MethodCallExpression methodCallExpression = null;

            if (obj == null)
            {
                methodCallExpression = objExpressions != null?
                                       Expression.Call
                                       (
                    methodInfoForMethodAcceptingObjArray,
                    Expression.NewArrayInit(typeof(object), objExpressions))
                                           :
                                           Expression.Call(methodInfoForMethodAcceptingObjArray);
            }
            else
            {
                methodCallExpression = objExpressions != null?
                                       Expression.Call
                                       (
                    Expression.Constant(obj),
                    methodInfoForMethodAcceptingObjArray,
                    Expression.NewArrayInit(typeof(object), objExpressions))
                                           :
                                           Expression.Call
                                           (
                                               Expression.Constant(obj),
                                               methodInfoForMethodAcceptingObjArray);
            }

            return(methodCallExpression, parameterExpressions?.OfType <ParameterExpression>()?.ToArray());
        }